Refactor

vuejs · May 13, 2020 · fbd2676 · fbd2676
1 parent b9c282e
commit fbd2676
Show file tree

Hide file tree

Showing 12 changed files with 725 additions and 655 deletions.
diff --git a/lib/rules/no-async-in-computed-properties.js b/lib/rules/no-async-in-computed-properties.js
@@ -72,7 +72,7 @@ module.exports = {
   },
 
   create (context) {
-    const forbiddenNodes = []
+    const computedPropertiesMap = new Map()
     let scopeStack = { upper: null, body: null }
 
     const expressionTypes = {
@@ -83,13 +83,9 @@ module.exports = {
       timed: 'timed function'
     }
 
-    function onFunctionEnter (node) {
+    function onFunctionEnter (node, { node: vueNode }) {
       if (node.async) {
-        forbiddenNodes.push({
-          node: node,
-          type: 'async',
-          targetBody: node.body
-        })
+        verify(node, node.body, 'async', computedPropertiesMap.get(vueNode))
       }
 
       scopeStack = { upper: scopeStack, body: node.body }
@@ -98,68 +94,53 @@ module.exports = {
     function onFunctionExit () {
       scopeStack = scopeStack.upper
     }
-    return Object.assign({},
-      {
-        ':function': onFunctionEnter,
-        ':function:exit': onFunctionExit,
-
-        NewExpression (node) {
-          if (node.callee.name === 'Promise') {
-            forbiddenNodes.push({
-              node: node,
-              type: 'new',
-              targetBody: scopeStack.body
-            })
-          }
-        },
-
-        CallExpression (node) {
-          if (isPromise(node)) {
-            forbiddenNodes.push({
-              node: node,
-              type: 'promise',
-              targetBody: scopeStack.body
-            })
-          } else if (isTimedFunction(node)) {
-            forbiddenNodes.push({
-              node: node,
-              type: 'timed',
-              targetBody: scopeStack.body
-            })
-          }
-        },
-
-        AwaitExpression (node) {
-          forbiddenNodes.push({
+
+    function verify (node, targetBody, type, computedProperties) {
+      computedProperties.forEach(cp => {
+        if (
+          cp.value &&
+          node.loc.start.line >= cp.value.loc.start.line &&
+          node.loc.end.line <= cp.value.loc.end.line &&
+          targetBody === cp.value
+        ) {
+          context.report({
             node: node,
-            type: 'await',
-            targetBody: scopeStack.body
-          })
-        }
-      },
-      utils.executeOnVue(context, (obj) => {
-        const computedProperties = utils.getComputedProperties(obj)
-
-        computedProperties.forEach(cp => {
-          forbiddenNodes.forEach(el => {
-            if (
-              cp.value &&
-              el.node.loc.start.line >= cp.value.loc.start.line &&
-              el.node.loc.end.line <= cp.value.loc.end.line &&
-              el.targetBody === cp.value
-            ) {
-              context.report({
-                node: el.node,
-                message: 'Unexpected {{expressionName}} in "{{propertyName}}" computed property.',
-                data: {
-                  expressionName: expressionTypes[el.type],
-                  propertyName: cp.key
-                }
-              })
+            message: 'Unexpected {{expressionName}} in "{{propertyName}}" computed property.',
+            data: {
+              expressionName: expressionTypes[type],
+              propertyName: cp.key
             }
           })
-        })
+        }
       })
-    )
+    }
+    return utils.defineVueVisitor(context, {
+      ObjectExpression (node, { node: vueNode }) {
+        if (node !== vueNode) {
+          return
+        }
+        computedPropertiesMap.set(node, utils.getComputedProperties(node))
+      },
+      ':function': onFunctionEnter,
+      ':function:exit': onFunctionExit,
+
+      NewExpression (node, { node: vueNode }) {
+        if (node.callee.name === 'Promise') {
+          verify(node, scopeStack.body, 'new', computedPropertiesMap.get(vueNode))
+        }
+      },
+
+      CallExpression (node, { node: vueNode }) {
+        if (isPromise(node)) {
+          verify(node, scopeStack.body, 'promise', computedPropertiesMap.get(vueNode))
+        } else if (isTimedFunction(node)) {
+          verify(node, scopeStack.body, 'timed', computedPropertiesMap.get(vueNode))
+        }
+      },
+
+      AwaitExpression (node, { node: vueNode }) {
+        verify(node, scopeStack.body, 'await', computedPropertiesMap.get(vueNode))
+      }
+    })
   }
 }
diff --git a/lib/rules/no-deprecated-events-api.js b/lib/rules/no-deprecated-events-api.js
@@ -30,28 +30,17 @@ module.exports = {
   },
 
   create (context) {
-    const forbiddenNodes = []
-
-    return Object.assign(
+    return utils.defineVueVisitor(context,
       {
         'CallExpression > MemberExpression > ThisExpression' (node) {
           if (!['$on', '$off', '$once'].includes(node.parent.property.name)) return
-          forbiddenNodes.push(node.parent.parent)
+
+          context.report({
+            node: node.parent.parent,
+            messageId: 'noDeprecatedEventsApi'
+          })
         }
-      },
-      utils.executeOnVue(context, (obj) => {
-        forbiddenNodes.forEach(node => {
-          if (
-            node.loc.start.line >= obj.loc.start.line &&
-            node.loc.end.line <= obj.loc.end.line
-          ) {
-            context.report({
-              node,
-              messageId: 'noDeprecatedEventsApi'
-            })
-          }
-        })
-      })
+      }
     )
   }
 }
diff --git a/lib/rules/no-lifecycle-after-await.js b/lib/rules/no-lifecycle-after-await.js
@@ -25,16 +25,6 @@ module.exports = {
   create (context) {
     const lifecycleHookCallNodes = new Set()
     const setupFunctions = new Map()
-    const forbiddenNodes = new Map()
-
-    function addForbiddenNode (property, node) {
-      let list = forbiddenNodes.get(property)
-      if (!list) {
-        list = []
-        forbiddenNodes.set(property, list)
-      }
-      list.push(node)
-    }
 
     let scopeStack = { upper: null, functionNode: null }
 
@@ -56,56 +46,53 @@ module.exports = {
           for (const { node } of tracker.iterateEsmReferences(traceMap)) {
             lifecycleHookCallNodes.add(node)
           }
-        },
-        'Property[value.type=/^(Arrow)?FunctionExpression$/]' (node) {
-          if (utils.getStaticPropertyName(node) !== 'setup') {
-            return
-          }
-
-          setupFunctions.set(node.value, {
-            setupProperty: node,
-            afterAwait: false
-          })
-        },
-        ':function' (node) {
-          scopeStack = { upper: scopeStack, functionNode: node }
-        },
-        'AwaitExpression' () {
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData) {
-            return
-          }
-          setupFunctionData.afterAwait = true
-        },
-        'CallExpression' (node) {
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData || !setupFunctionData.afterAwait) {
-            return
-          }
-
-          if (lifecycleHookCallNodes.has(node)) {
-            addForbiddenNode(setupFunctionData.setupProperty, node)
-          }
-        },
-        ':function:exit' (node) {
-          scopeStack = scopeStack.upper
-
-          setupFunctions.delete(node)
         }
       },
-      utils.executeOnVue(context, obj => {
-        const reportsList = obj.properties
-          .map(item => forbiddenNodes.get(item))
-          .filter(reports => !!reports)
-        for (const reports of reportsList) {
-          for (const node of reports) {
-            context.report({
-              node,
-              messageId: 'forbidden'
+      utils.defineVueVisitor(context,
+        {
+          'Property[value.type=/^(Arrow)?FunctionExpression$/]' (node, { node: vueNode }) {
+            if (node.parent !== vueNode) {
+              return
+            }
+            if (utils.getStaticPropertyName(node) !== 'setup') {
+              return
+            }
+
+            setupFunctions.set(node.value, {
+              setupProperty: node,
+              afterAwait: false
             })
+          },
+          ':function' (node) {
+            scopeStack = { upper: scopeStack, functionNode: node }
+          },
+          'AwaitExpression' () {
+            const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
+            if (!setupFunctionData) {
+              return
+            }
+            setupFunctionData.afterAwait = true
+          },
+          'CallExpression' (node) {
+            const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
+            if (!setupFunctionData || !setupFunctionData.afterAwait) {
+              return
+            }
+
+            if (lifecycleHookCallNodes.has(node)) {
+              context.report({
+                node,
+                messageId: 'forbidden'
+              })
+            }
+          },
+          ':function:exit' (node) {
+            scopeStack = scopeStack.upper
+
+            setupFunctions.delete(node)
           }
-        }
-      })
+        },
+      )
     )
   }
 }