Add new function findMissingReturns

Author: armano2

lib/rules/require-render-return.js

@@ -6,6 +6,38 @@
 
 const utils = require('../utils')
 
+function create (context) {
+  const forbiddenNodes = []
+
+  // ----------------------------------------------------------------------
+  // Public
+  // ----------------------------------------------------------------------
+
+  return Object.assign({},
+    utils.findMissingReturns(forbiddenNodes, true),
+    utils.executeOnVue(context, obj => {
+      const node = obj.properties.find(item => item.type === 'Property' &&
+        utils.getStaticPropertyName(item) === 'render' &&
+        (item.value.type === 'ArrowFunctionExpression' || item.value.type === 'FunctionExpression') &&
+        !item.value.expression // render: () => test
+      )
+      if (!node) return
+
+      forbiddenNodes.forEach(el => {
+        if (
+          el.loc.start.line >= node.value.loc.start.line &&
+          el.loc.end.line <= node.value.loc.end.line
+        ) {
+          context.report({
+            node: node.key,
+            message: 'Expected to return a value in render function.'
+          })
+        }
+      })
+    })
+  )
+}
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -21,22 +53,5 @@ module.exports = {
     schema: []
   },
 
-  create (context) {
-    return utils.executeOnVue(context, obj => {
-      const node = obj.properties.find(item => item.type === 'Property' &&
-        utils.getStaticPropertyName(item) === 'render' &&
-        (item.value.type === 'ArrowFunctionExpression' || item.value.type === 'FunctionExpression') &&
-        !item.value.expression // render: () => test
-      )
-      if (node) {
-        const body = node.value.body
-        if (body.type === 'BlockStatement' && !body.body.find(item => item.type === 'ReturnStatement')) {
-          context.report({
-            node: node.key,
-            message: 'Expected to return a value in render function.'
-          })
-        }
-      }
-    })
-  }
+  create
 }

lib/rules/return-in-computed-property.js

@@ -10,69 +10,26 @@ function create (context) {
   const options = context.options[0] || {}
   const treatUndefinedAsUnspecified = !(options.treatUndefinedAsUnspecified === false)
 
-  let funcInfo = {
-    funcInfo: null,
-    codePath: null,
-    hasReturn: false,
-    hasReturnValue: false,
-    node: null
-  }
   const forbiddenNodes = []
 
-  // ----------------------------------------------------------------------
-  // Helpers
-  // ----------------------------------------------------------------------
-  function isValidReturn () {
-    if (!funcInfo.hasReturn) {
-      return false
-    }
-    return !treatUndefinedAsUnspecified || funcInfo.hasReturnValue
-  }
-
   // ----------------------------------------------------------------------
   // Public
   // ----------------------------------------------------------------------
 
   return Object.assign({},
-    {
-      onCodePathStart (codePath, node) {
-        funcInfo = {
-          codePath,
-          funcInfo: funcInfo,
-          hasReturn: false,
-          hasReturnValue: false,
-          node
-        }
-      },
-      onCodePathEnd () {
-        funcInfo = funcInfo.funcInfo
-      },
-      ReturnStatement (node) {
-        funcInfo.hasReturn = true
-        funcInfo.hasReturnValue = Boolean(node.argument)
-      },
-      'FunctionExpression:exit' (node) {
-        if (!isValidReturn()) {
-          forbiddenNodes.push({
-            hasReturn: funcInfo.hasReturn,
-            node: funcInfo.node,
-            type: 'return'
-          })
-        }
-      }
-    },
+    utils.findMissingReturns(forbiddenNodes, treatUndefinedAsUnspecified),
     utils.executeOnVue(context, properties => {
       const computedProperties = utils.getComputedProperties(properties)
 
       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.loc.start.line >= cp.value.loc.start.line &&
+            el.loc.end.line <= cp.value.loc.end.line
           ) {
             context.report({
-              node: el.node,
+              node: el,
               message: 'Expected to return a value in "{{name}}" computed property.',
               data: {
                 name: cp.key

lib/utils/index.js

@@ -439,5 +439,56 @@ module.exports = {
         cb(node.arguments.slice(-1)[0])
       }
     }
+  },
+
+  /**
+   * Find all function witch do not allways return values
+   * @param {Array} nodes an array nodes
+   * @param {boolean} treatUndefinedAsUnspecified
+   */
+  findMissingReturns (nodes, treatUndefinedAsUnspecified) {
+    let funcInfo = {
+      funcInfo: null,
+      codePath: null,
+      hasReturn: false,
+      hasReturnValue: false,
+      node: null
+    }
+
+    function isValidReturn () {
+      if (!funcInfo.hasReturn) {
+        return false
+      }
+      return !treatUndefinedAsUnspecified || funcInfo.hasReturnValue
+    }
+
+    return {
+      onCodePathStart (codePath, node) {
+        funcInfo = {
+          codePath,
+          funcInfo: funcInfo,
+          hasReturn: false,
+          hasReturnValue: false,
+          node
+        }
+      },
+      onCodePathEnd () {
+        funcInfo = funcInfo.funcInfo
+      },
+      ReturnStatement (node) {
+        funcInfo.hasReturn = true
+        funcInfo.hasReturnValue = Boolean(node.argument)
+      },
+      'ArrowFunctionExpression:exit' (node) {
+        if (!isValidReturn()) {
+          nodes.push(funcInfo.node)
+        }
+      },
+      'FunctionExpression:exit' (node) {
+        if (!isValidReturn()) {
+          nodes.push(funcInfo.node)
+        }
+      }
+    }
   }
 }

tests/lib/rules/require-render-return.js

@@ -75,6 +75,19 @@ ruleTester.run('require-render-return', rule, {
         render: () => null
       }`,
       parserOptions
+    },
+    {
+      filename: 'test.vue',
+      code: `export default {
+        render() {
+          if (a) {
+            return \`<div>a</div>\`
+          } else {
+            return \`<span>a</span>\`
+          }
+        }
+      }`,
+      parserOptions
     }
   ],
 

tests/lib/rules/return-in-computed-property.js

@@ -38,6 +38,13 @@ ruleTester.run('return-in-computed-property', rule, {
               get () {
                 return true
               }
+            },
+            bar4 () {
+              if (foo) {
+                return true
+              } else {
+                return false
+              }
             }
           }
         }