Instead of passing callback return generator function

Author: armano2

lib/rules/no-dupe-keys.js

@@ -23,18 +23,19 @@ function create (context) {
   // ----------------------------------------------------------------------
 
   return utils.executeOnVue(context, (obj) => {
-    utils.iterateProperties(obj, groups, (name, node, groupName) => {
-      if (usedNames.indexOf(name) !== -1) {
+    const properties = utils.iterateProperties(obj, groups)
+    for (const o of properties) {
+      if (usedNames.indexOf(o.name) !== -1) {
         context.report({
-          node: node,
+          node: o.node,
           message: "Duplicated key '{{name}}'.",
           data: {
-            name
+            name: o.name
           }
         })
       }
-      usedNames.push(name)
-    })
+      usedNames.push(o.name)
+    }
   })
 }
 

lib/rules/no-reservered-keys.js

@@ -23,25 +23,26 @@ function create (context) {
   // ----------------------------------------------------------------------
 
   return utils.executeOnVue(context, (obj) => {
-    utils.iterateProperties(obj, groups, (name, node, groupName) => {
-      if (groupName === 'data' && name[0] === '_') {
+    const properties = utils.iterateProperties(obj, groups)
+    for (const o of properties) {
+      if (o.groupName === 'data' && o.name[0] === '_') {
         context.report({
-          node: node,
+          node: o.node,
           message: "Keys starting with with '_' are reserved in '{{name}}' group.",
           data: {
-            name
+            name: o.name
           }
         })
-      } else if (reservedKeys.has(name)) {
+      } else if (reservedKeys.has(o.name)) {
         context.report({
-          node: node,
+          node: o.node,
           message: "Key '{{name}}' is reserved.",
           data: {
-            name
+            name: o.name
           }
         })
       }
-    })
+    }
   })
 }
 

lib/utils/index.js

@@ -442,67 +442,70 @@ module.exports = {
     }
   },
 
-  iterateProperties (node, groups, cb) {
-    node.properties
-      .filter(p => p.type === 'Property' && groups.has(this.getStaticPropertyName(p.key)))
-      .forEach(node => {
-        const name = this.getStaticPropertyName(node.key)
-        if (node.value.type === 'ArrayExpression') {
-          this.iterateArrayExpression(node.value, name, cb)
-        } else if (node.value.type === 'ObjectExpression') {
-          this.iterateObjectExpression(node.value, name, cb)
-        } else if (node.value.type === 'FunctionExpression') {
-          this.iterateFunctionExpression(node.value, name, cb)
-        }
-      })
+  /**
+   * Return generator with all properties
+   * @param {ASTNode} node Node to check
+   * @param {string} groupName Name of parent group
+   */
+  * iterateProperties (node, groups) {
+    const nodes = node.properties.filter(p => p.type === 'Property' && groups.has(this.getStaticPropertyName(p.key)))
+    for (const item of nodes) {
+      const name = this.getStaticPropertyName(item.key)
+      if (item.value.type === 'ArrayExpression') {
+        yield * this.iterateArrayExpression(item.value, name)
+      } else if (item.value.type === 'ObjectExpression') {
+        yield * this.iterateObjectExpression(item.value, name)
+      } else if (item.value.type === 'FunctionExpression') {
+        yield * this.iterateFunctionExpression(item.value, name)
+      }
+    }
   },
 
   /**
-   * Interate over all elements inside ArrayExpression
+   * Return generator with all elements inside ArrayExpression
    * @param {ASTNode} node Node to check
    * @param {string} groupName Name of parent group
-   * @param {*} cb Callback function to iterate over nodes
    */
-  iterateArrayExpression (node, groupName, cb) {
+  * iterateArrayExpression (node, groupName) {
     assert(node.type === 'ArrayExpression')
-    node.elements.forEach(item => {
+    for (const item of node.elements) {
       const name = this.getStaticPropertyName(item)
       if (name) {
-        cb(name, item, groupName)
+        const obj = { name, groupName, node: item }
+        yield obj
       }
-    })
+    }
   },
 
   /**
-   * Interate over all elements inside ObjectExpression
+   * Return generator with all elements inside ObjectExpression
    * @param {ASTNode} node Node to check
    * @param {string} groupName Name of parent group
-   * @param {*} cb Callback function to iterate over nodes
    */
-  iterateObjectExpression (node, groupName, cb) {
+  * iterateObjectExpression (node, groupName) {
     assert(node.type === 'ObjectExpression')
-    node.properties.forEach(item => {
+    for (const item of node.properties) {
       const name = this.getStaticPropertyName(item)
       if (name) {
-        cb(name, item.key, groupName)
+        const obj = { name, groupName, node: item.key }
+        yield obj
       }
-    })
+    }
   },
 
   /**
-   * Interate over all elements inside FunctionExpression
+   * Return generator with all elements inside FunctionExpression
    * @param {ASTNode} node Node to check
    * @param {string} groupName Name of parent group
-   * @param {*} cb Callback function to iterate over nodes
    */
-  iterateFunctionExpression (node, groupName, cb) {
+  * iterateFunctionExpression (node, groupName) {
     assert(node.type === 'FunctionExpression')
     if (node.body.type === 'BlockStatement') {
-      node.body.body.forEach(item => {
+      for (const item of node.body.body) {
         if (item.type === 'ReturnStatement' && item.argument.type === 'ObjectExpression') {
-          this.iterateObjectExpression(item.argument, groupName, cb)
+          yield * this.iterateObjectExpression(item.argument, groupName)
         }
-      })
+      }
     }
   }
 }