Add support for reserved names in data & rename rule

Author: armano2

docs/rules/no-duplicate-field-names.md renamed to docs/rules/no-dupe-keys.md

@@ -1,4 +1,4 @@
-# Prevent duplicate field names (no-duplicate-field-names)
+# Prevent duplicate field names (no-dupe-keys)
 
 This rule prevents to use duplicated names and reserved/internal names from vue.
 
@@ -61,7 +61,7 @@ This rule has an object option:
 ### Example 1:
 
 ```
-vue/no-duplicate-field-names: [2, {
+vue/no-dupe-keys: [2, {
   reserved: ['foo']
 }]
 ```
@@ -79,7 +79,7 @@ export default {
 ### Example 2:
 
 ```
-vue/no-duplicate-field-names: [2, {
+vue/no-dupe-keys: [2, {
   scope: ['asyncComputed']
 }]
 ```

lib/rules/no-duplicate-field-names.js renamed to lib/rules/no-dupe-keys.js

@@ -6,6 +6,7 @@
 
 const utils = require('../utils')
 const assert = require('assert')
+const getPropertyName = require('eslint/lib/ast-utils').getStaticPropertyName
 
 const RESERVER_NAMES = new Set(require('../utils/vue-reserved.json'))
 const SCOPE_NAMES = new Set(['props', 'computed', 'data', 'methods'])
@@ -31,50 +32,60 @@ function create (context) {
   // Helpers
   // ----------------------------------------------------------------------
 
-  function checkUsedNames (name, node) {
+  function checkUsedNames (name, node, groupName) {
     assert(typeof name === 'string')
 
-    if (reservedNames.has(name)) {
+    if (groupName === 'data' && name.substr(0, 1) === '_') {
       context.report({
         node: node,
-        message: 'Reserved key \'{{name}}\'.',
+        message: "Field '{{name}}' which start with _ in data is reserved.",
         data: {
-          name: name
+          name
+        }
+      })
+    } else if (reservedNames.has(name)) {
+      context.report({
+        node: node,
+        message: "Reserved key '{{name}}'.",
+        data: {
+          name
         }
       })
     } else if (usedNames.indexOf(name) !== -1) {
       context.report({
         node: node,
-        message: 'Duplicate key \'{{name}}\'.',
+        message: "Duplicate key '{{name}}'.",
         data: {
-          name: name
+          name
         }
       })
     }
     usedNames.push(name)
   }
 
-  function checkArrayExpression (node) {
+  function checkArrayExpression (node, groupName) {
     node.elements.forEach(item => {
-      if (item.type === 'Literal') {
-        checkUsedNames(item.value, item)
+      const name = utils.getStaticPropertyName(item)
+      if (name) {
+        checkUsedNames(name, item, groupName)
       }
     })
   }
 
-  function checkObjectExpression (node) {
+  function checkObjectExpression (node, groupName) {
     node.properties.forEach(item => {
-      if (item.type === 'Property' && item.key.type === 'Identifier') {
-        checkUsedNames(item.key.name, item.key)
+      const name = utils.getStaticPropertyName(item)
+      if (name) {
+        checkUsedNames(name, item.key, groupName)
       }
     })
   }
 
-  function checkFunctionExpression (node) {
+  function checkFunctionExpression (node, groupName) {
     if (node.body.type === 'BlockStatement') {
       node.body.body.forEach(item => {
         if (item.type === 'ReturnStatement' && item.argument.type === 'ObjectExpression') {
-          checkObjectExpression(item.argument)
+          checkObjectExpression(item.argument, groupName)
         }
       })
     }
@@ -89,11 +100,11 @@ function create (context) {
       .filter(p => p.type === 'Property' && p.key.type === 'Identifier' && scopeNames.has(p.key.name))
       .forEach(node => {
         if (node.value.type === 'ArrayExpression') {
-          checkArrayExpression(node.value)
+          checkArrayExpression(node.value, node.key.name)
         } else if (node.value.type === 'ObjectExpression') {
-          checkObjectExpression(node.value)
+          checkObjectExpression(node.value, node.key.name)
         } else if (node.value.type === 'FunctionExpression') {
-          checkFunctionExpression(node.value)
+          checkFunctionExpression(node.value, node.key.name)
         }
       })
   })

lib/utils/index.js

@@ -272,6 +272,48 @@ module.exports = {
     return members.reverse()
   },
 
+  /**
+   * Gets the property name of a given node.
+   * @param {ASTNode} node - The node to get.
+   * @return {string|null} The property name if static. Otherwise, null.
+   */
+  getStaticPropertyName (node) {
+    let prop
+    switch (node && node.type) {
+      case 'Property':
+      case 'MethodDefinition':
+        prop = node.key
+        break
+      case 'MemberExpression':
+        prop = node.property
+        break
+      case 'Literal':
+      case 'TemplateLiteral':
+      case 'Identifier':
+        prop = node
+        break
+      // no default
+    }
+
+    switch (prop && prop.type) {
+      case 'Literal':
+        return String(prop.value)
+      case 'TemplateLiteral':
+        if (prop.expressions.length === 0 && prop.quasis.length === 1) {
+          return prop.quasis[0].value.cooked
+        }
+        break
+      case 'Identifier':
+        if (!node.computed) {
+          return prop.name
+        }
+        break
+      // no default
+    }
+
+    return null
+  },
+
   /**
    * Get all computed properties by looking at all component's properties
    * @param {ObjectExpression} Object with component definition