Add ywait & yield & async & promise

Author: armano2

lib/recommended-rules.js

@@ -8,6 +8,7 @@ module.exports = {
   "vue/html-no-self-closing": "off",
   "vue/html-quotes": "off",
   "vue/jsx-uses-vars": "error",
+  "vue/no-async-in-computed-properties": "off",
   "vue/no-confusing-v-for-v-if": "error",
   "vue/no-duplicate-attributes": "off",
   "vue/no-invalid-template-root": "error",

lib/rules/no-async-in-computed-properties.js

@@ -0,0 +1,134 @@
+/**
+ * @fileoverview Check if there are no async inside computed properties
+ * @author Armano
+ */
+'use strict'
+
+const utils = require('../utils')
+
+var PROMISE_FUNCTIONS = [
+  'then',
+  'catch',
+  'finally'
+]
+
+var PROMISE_METHODS = [
+  'all',
+  'race',
+  'reject',
+  'resolve'
+]
+
+function isPromise (node) {
+  if (node.type === 'CallExpression' && node.callee && node.callee.type === 'MemberExpression') {
+    return ( // hello.then() ||  hello.catch()
+      node.callee.property &&
+      PROMISE_FUNCTIONS.indexOf(node.callee.property.name) !== -1
+    ) || ( // Promise.STATIC_METHOD()
+      node.callee.object.type === 'Identifier' &&
+      node.callee.object.name === 'Promise' &&
+      PROMISE_METHODS.indexOf(node.callee.property.name) !== -1
+    ) || ( // somePromise.ANYTHING()
+      node.callee.object && isPromise(node.callee.object)
+    )
+  }
+  return false
+}
+
+function create (context) {
+  const forbiddenNodes = []
+
+  function onFunctionEnter (node) {
+    if (node.async) {
+      forbiddenNodes.push({
+        node: node,
+        type: 'async'
+      })
+    }
+  }
+
+  return Object.assign({},
+    {
+      FunctionDeclaration: onFunctionEnter,
+
+      FunctionExpression: onFunctionEnter,
+
+      ArrowFunctionExpression: onFunctionEnter,
+
+      CallExpression (node) {
+        if (isPromise(node)) {
+          forbiddenNodes.push({
+            node: node,
+            type: 'promise'
+          })
+        }
+      },
+
+      YieldExpression (node) {
+        // await nodes are YieldExpression's with babel-eslint < 7.0.0
+        forbiddenNodes.push({
+          node: node,
+          type: 'yield'
+        })
+      },
+
+      AwaitExpression (node) {
+        forbiddenNodes.push({
+          node: node,
+          type: 'await'
+        })
+      }
+    },
+    utils.executeOnVueComponent(context, (properties) => {
+      const computedProperties = utils.getComputedProperties(properties)
+
+      computedProperties.forEach(cp => {
+        forbiddenNodes.forEach(({ type, node }) => {
+          if (
+            node.loc.start.line >= cp.value.loc.start.line &&
+            node.loc.end.line <= cp.value.loc.end.line
+          ) {
+            if (type === 'await') {
+              context.report({
+                node: node,
+                message: `Unexpected await in "${cp.key}" computed property.`
+              })
+            } else if (type === 'yield') {
+              context.report({
+                node: node,
+                message: `Unexpected yield in "${cp.key}" computed property.`
+              })
+            } else if (type === 'async') {
+              context.report({
+                node: node,
+                message: `Unexpected async in "${cp.key}" computed property.`
+              })
+            } else if (type === 'promise') {
+              context.report({
+                node: node,
+                message: `Unexpected asynchronous action in "${cp.key}" computed property.`
+              })
+            }
+          }
+        })
+      })
+    })
+  )
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  create,
+  meta: {
+    docs: {
+      description: 'Check if there are no async inside computed properties',
+      category: 'Best Practices',
+      recommended: false
+    },
+    fixable: null,
+    schema: []
+  }
+}