Blame view

node_modules/eslint/lib/rules/no-restricted-globals.js 3.71 KB
ce4c83ff   wxy   初始提交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
  /**
   * @fileoverview Restrict usage of specified globals.
   * @author Benoît Zugmeyer
   */
  "use strict";
  
  //------------------------------------------------------------------------------
  // Helpers
  //------------------------------------------------------------------------------
  
  const DEFAULT_MESSAGE_TEMPLATE = "Unexpected use of '{{name}}'.",
      CUSTOM_MESSAGE_TEMPLATE = "Unexpected use of '{{name}}'. {{customMessage}}";
  
  //------------------------------------------------------------------------------
  // Rule Definition
  //------------------------------------------------------------------------------
  
  module.exports = {
      meta: {
          docs: {
              description: "disallow specified global variables",
              category: "Variables",
              recommended: false,
              url: "https://eslint.org/docs/rules/no-restricted-globals"
          },
  
          schema: {
              type: "array",
              items: {
                  oneOf: [
                      {
                          type: "string"
                      },
                      {
                          type: "object",
                          properties: {
                              name: { type: "string" },
                              message: { type: "string" }
                          },
                          required: ["name"],
                          additionalProperties: false
                      }
                  ]
              },
              uniqueItems: true,
              minItems: 0
          }
      },
  
      create(context) {
  
          // If no globals are restricted, we don't need to do anything
          if (context.options.length === 0) {
              return {};
          }
  
          const restrictedGlobalMessages = context.options.reduce((memo, option) => {
              if (typeof option === "string") {
                  memo[option] = null;
              } else {
                  memo[option.name] = option.message;
              }
  
              return memo;
          }, {});
  
          /**
           * Report a variable to be used as a restricted global.
           * @param {Reference} reference the variable reference
           * @returns {void}
           * @private
           */
          function reportReference(reference) {
              const name = reference.identifier.name,
                  customMessage = restrictedGlobalMessages[name],
                  message = customMessage
                      ? CUSTOM_MESSAGE_TEMPLATE
                      : DEFAULT_MESSAGE_TEMPLATE;
  
              context.report({
                  node: reference.identifier,
                  message,
                  data: {
                      name,
                      customMessage
                  }
              });
          }
  
          /**
           * Check if the given name is a restricted global name.
           * @param {string} name name of a variable
           * @returns {boolean} whether the variable is a restricted global or not
           * @private
           */
          function isRestricted(name) {
              return restrictedGlobalMessages.hasOwnProperty(name);
          }
  
          return {
              Program() {
                  const scope = context.getScope();
  
                  // Report variables declared elsewhere (ex: variables defined as "global" by eslint)
                  scope.variables.forEach(variable => {
                      if (!variable.defs.length && isRestricted(variable.name)) {
                          variable.references.forEach(reportReference);
                      }
                  });
  
                  // Report variables not declared at all
                  scope.through.forEach(reference => {
                      if (isRestricted(reference.identifier.name)) {
                          reportReference(reference);
                      }
                  });
  
              }
          };
      }
  };