Merge remote-tracking branch 'vuejs/master' into patch-10-prop-specificity

Author: armano2

docs/rules/no-async-in-computed-properties.md

@@ -0,0 +1,60 @@
+# Check if there are no asynchronous actions inside computed properties (no-async-in-computed-properties)
+
+Computed properties should be synchronous. Asynchronous actions inside them may not work as expected and can lead to an unexpected behaviour, that's why you should avoid them.
+If you need async computed properties you might want to consider using additional plugin [vue-async-computed]
+
+## :book: Rule Details
+
+This rule is aimed at preventing asynchronous methods from being called in computed properties.
+
+:-1: Examples of **incorrect** code for this rule:
+
+```js
+export default {
+  computed: {
+    pro () {
+      return Promise.all([new Promise((resolve, reject) => {})])
+    },
+    foo: async function () {
+      return await someFunc()
+    },
+    bar () {
+      return fetch(url).then(response => {})
+    },
+    tim () {
+      setTimeout(() => { }, 0)
+    },
+    inter () {
+      setInterval(() => { }, 0)
+    },
+    anim () {
+      requestAnimationFrame(() => {})
+    }
+  }
+}
+```
+
+:+1: Examples of **correct** code for this rule:
+
+```js
+export default {
+  computed: {
+    foo () {
+      var bar = 0
+      try {
+        bar = bar / this.a
+      } catch (e) {
+        return 0
+      } finally {
+        return bar
+      }
+    }
+  }
+}
+```
+
+## :wrench: Options
+
+Nothing.
+
+[vue-async-computed]: https://github.com/foxbenjaminfox/vue-async-computed

docs/rules/no-shared-component-data.md

@@ -0,0 +1,33 @@
+# Enforces component's data property to be a function (no-shared-component-data)
+
+When using the data property on a component (i.e. anywhere except on `new Vue`), the value must be a function that returns an object.
+
+## :book: Rule Details
+
+When the value of `data` is an object, it’s shared across all instances of a component.
+
+:-1: Examples of **incorrect** code for this rule:
+
+```js
+Vue.component('some-comp', {
+  data: {
+    foo: 'bar'
+  }
+})
+```
+
+:+1: Examples of **correct** code for this rule:
+
+```js
+Vue.component('some-comp', {
+  data: function () {
+    return {
+      foo: 'bar'
+    }
+  }
+})
+```
+
+## :wrench: Options
+
+Nothing.

lib/rules/name-property-casing.js

@@ -55,7 +55,7 @@ function create (context) {
   // Public
   // ----------------------------------------------------------------------
 
-  return utils.executeOnVueComponent(context, (obj) => {
+  return utils.executeOnVue(context, (obj) => {
     const node = obj.properties
       .filter(item => (
         item.type === 'Property' &&

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

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview Check if there are no asynchronous actions inside computed properties.
+ * @author Armano
+ */
+'use strict'
+
+const utils = require('../utils')
+
+const PROMISE_FUNCTIONS = [
+  'then',
+  'catch',
+  'finally'
+]
+
+const PROMISE_METHODS = [
+  'all',
+  'race',
+  'reject',
+  'resolve'
+]
+
+const TIMED_FUNCTIONS = [
+  'setTimeout',
+  'setInterval',
+  'setImmediate',
+  'requestAnimationFrame'
+]
+
+function isTimedFunction (node) {
+  return (
+    node.type === 'CallExpression' &&
+    node.callee.type === 'Identifier' &&
+    TIMED_FUNCTIONS.indexOf(node.callee.name) !== -1
+  ) || (
+    node.type === 'CallExpression' &&
+    node.callee.type === 'MemberExpression' &&
+    node.callee.object.type === 'Identifier' &&
+    node.callee.object.name === 'window' && (
+      TIMED_FUNCTIONS.indexOf(node.callee.property.name) !== -1
+    )
+  ) && node.arguments.length
+}
+
+function isPromise (node) {
+  if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression') {
+    return ( // hello.PROMISE_FUNCTION()
+      node.callee.property.type === 'Identifier' &&
+      PROMISE_FUNCTIONS.indexOf(node.callee.property.name) !== -1
+    ) || ( // Promise.PROMISE_METHOD()
+      node.callee.object.type === 'Identifier' &&
+      node.callee.object.name === 'Promise' &&
+      PROMISE_METHODS.indexOf(node.callee.property.name) !== -1
+    )
+  }
+  return false
+}
+
+function create (context) {
+  const forbiddenNodes = []
+
+  const expressionTypes = {
+    promise: 'asynchronous action',
+    await: 'await operator',
+    async: 'async function declaration',
+    new: 'Promise object',
+    timed: 'timed function'
+  }
+
+  function onFunctionEnter (node) {
+    if (node.async) {
+      forbiddenNodes.push({
+        node: node,
+        type: 'async'
+      })
+    }
+  }
+
+  return Object.assign({},
+    {
+      FunctionDeclaration: onFunctionEnter,
+
+      FunctionExpression: onFunctionEnter,
+
+      ArrowFunctionExpression: onFunctionEnter,
+
+      NewExpression (node) {
+        if (node.callee.name === 'Promise') {
+          forbiddenNodes.push({
+            node: node,
+            type: 'new'
+          })
+        }
+      },
+
+      CallExpression (node) {
+        if (isPromise(node)) {
+          forbiddenNodes.push({
+            node: node,
+            type: 'promise'
+          })
+        }
+        if (isTimedFunction(node)) {
+          forbiddenNodes.push({
+            node: node,
+            type: 'timed'
+          })
+        }
+      },
+
+      AwaitExpression (node) {
+        forbiddenNodes.push({
+          node: node,
+          type: 'await'
+        })
+      }
+    },
+    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
+          ) {
+            context.report({
+              node: el.node,
+              message: 'Unexpected {{expressionName}} in "{{propertyName}}" computed property.',
+              data: {
+                expressionName: expressionTypes[el.type],
+                propertyName: cp.key
+              }
+            })
+          }
+        })
+      })
+    })
+  )
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  create,
+  meta: {
+    docs: {
+      description: 'Check if there are no asynchronous actions inside computed properties.',
+      category: 'Best Practices',
+      recommended: false
+    },
+    fixable: null,
+    schema: []
+  }
+}

lib/rules/no-shared-component-data.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Enforces component's data property to be a function.
+ * @author Armano
+ */
+'use strict'
+
+const utils = require('../utils')
+
+function create (context) {
+  // ----------------------------------------------------------------------
+  // Public
+  // ----------------------------------------------------------------------
+
+  return utils.executeOnVueComponent(context, (obj) => {
+    obj.properties
+      .filter(p =>
+        p.type === 'Property' &&
+        p.key.type === 'Identifier' &&
+        p.key.name === 'data' &&
+        p.value.type !== 'FunctionExpression' &&
+        p.value.type !== 'Identifier'
+      )
+      .forEach(cp => {
+        context.report({
+          node: cp.value,
+          message: '`data` property in component must be a function'
+        })
+      })
+  })
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      description: "Enforces component's data property to be a function.",
+      category: 'Possible Errors',
+      recommended: false
+    },
+    fixable: null,  // or "code" or "whitespace"
+    schema: [
+      // fill in your schema
+    ]
+  },
+
+  create
+}

lib/rules/no-side-effects-in-computed-properties.js

@@ -33,12 +33,13 @@ function create (context) {
         }
       }
     },
-    utils.executeOnVueComponent(context, (obj) => {
+    utils.executeOnVue(context, (obj) => {
       const computedProperties = utils.getComputedProperties(obj)
 
       computedProperties.forEach(cp => {
         forbiddenNodes.forEach(node => {
           if (
+            cp.value &&
             node.loc.start.line >= cp.value.loc.start.line &&
             node.loc.end.line <= cp.value.loc.end.line
           ) {

lib/rules/order-in-components.js

@@ -80,7 +80,7 @@ function create (context) {
   const extendedOrder = order.map(property => groups[property] || property)
   const orderMap = getOrderMap(extendedOrder)
 
-  return utils.executeOnVueComponent(context, (obj) => {
+  return utils.executeOnVue(context, (obj) => {
     checkOrder(obj.properties, orderMap, context)
   })
 }

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

@@ -61,7 +61,7 @@ function create (context) {
         }
       }
     },
-    utils.executeOnVueComponent(context, properties => {
+    utils.executeOnVue(context, properties => {
       const computedProperties = utils.getComputedProperties(properties)
 
       computedProperties.forEach(cp => {

lib/utils/index.js

@@ -405,6 +405,25 @@ module.exports = {
       node.arguments[0].type === 'ObjectExpression'
   },
 
+  executeOnVue (context, cb) {
+    return Object.assign(
+      this.executeOnVueComponent(context, cb),
+      this.executeOnVueInstance(context, cb)
+    )
+  },
+
+  executeOnVueInstance (context, cb) {
+    const _this = this
+
+    return {
+      'NewExpression:exit' (node) {
+        // new Vue({})
+        if (!_this.isVueInstance(node)) return
+        cb(node.arguments[0])
+      }
+    }
+  },
+
   executeOnVueComponent (context, cb) {
     const filePath = context.getFilename()
     const _this = this
@@ -419,11 +438,6 @@ module.exports = {
         // Vue.component('xxx', {}) || component('xxx', {})
         if (!_this.isVueComponent(node)) return
         cb(node.arguments.slice(-1)[0])
-      },
-      'NewExpression:exit' (node) {
-        // new Vue({})
-        if (!_this.isVueInstance(node)) return
-        cb(node.arguments[0])
       }
     }
   }