Add no-duplicate-field-names rule.

Author: armano2

docs/rules/no-duplicate-field-names.md

@@ -0,0 +1,98 @@
+# Prevent duplicate field names (no-duplicate-field-names)
+
+This rule prevents to use duplicated names and reserved/internal names from vue.
+
+## :book: Rule Details
+
+This rule is aimed at preventing duplicated property names.
+
+:-1: Examples of **incorrect** code for this rule:
+
+```js
+export default {
+  props: {
+    foo: String
+  },
+  computed: {
+    foo: {
+      get () {
+      }
+    }
+  },
+  data: {
+    foo: null
+  },
+  methods: {
+    foo () {
+    }
+  }
+}
+```
+
+:+1: Examples of **correct** code for this rule:
+
+```js
+export default {
+  props: ['foo'],
+  computed: {
+    bar () {
+    }
+  },
+  data () {
+    return {
+      dat: null
+    }
+  },
+  methods: {
+    test () {
+    }
+  }
+}
+```
+
+## :wrench: Options
+
+This rule has an object option:
+
+`"reserved"`: [] (default) array of dissalowed names inside `scopes`.
+
+`"scope"`: [] (default) array of additional scopes to search for duplicates.
+
+### Example 1:
+
+```
+vue/no-duplicate-field-names: [2, {
+  reserved: ['foo']
+}]
+```
+
+:-1: Examples of **incorrect** code for this configuration
+
+```js
+export default {
+  computed: {
+    foo () {}
+  }
+}
+```
+
+### Example 2:
+
+```
+vue/no-duplicate-field-names: [2, {
+  scope: ['asyncComputed']
+}]
+```
+
+:-1: Examples of **incorrect** code for this configuration
+
+```js
+export default {
+  computed: {
+    foo () {}
+  },
+  asyncComputed: {
+    foo () {}
+  }
+}
+```

lib/rules/no-duplicate-field-names.js

@@ -0,0 +1,131 @@
+/**
+ * @fileoverview Prevent duplicate field names
+ * @author Armano
+ */
+'use strict'
+
+const utils = require('../utils')
+const assert = require('assert')
+
+const RESERVER_NAMES = new Set(require('../utils/vue-reserved.json'))
+const SCOPE_NAMES = new Set(['props', 'computed', 'data', 'methods'])
+
+function create (context) {
+  const usedNames = []
+  const reservedNames = RESERVER_NAMES
+  const scopeNames = SCOPE_NAMES
+
+  const options = context.options[0] || {}
+  if (options.reserved) {
+    options.reserved.forEach(name => {
+      reservedNames.add(name)
+    })
+  }
+  if (options.scope) {
+    options.scope.forEach(name => {
+      scopeNames.add(name)
+    })
+  }
+
+  // ----------------------------------------------------------------------
+  // Helpers
+  // ----------------------------------------------------------------------
+
+  function checkUsedNames (name, node) {
+    assert(typeof name === 'string')
+
+    if (reservedNames.has(name)) {
+      context.report({
+        node: node,
+        message: 'Reserved key \'{{name}}\'.',
+        data: {
+          name: name
+        }
+      })
+    } else if (usedNames.indexOf(name) !== -1) {
+      context.report({
+        node: node,
+        message: 'Duplicate key \'{{name}}\'.',
+        data: {
+          name: name
+        }
+      })
+    }
+    usedNames.push(name)
+  }
+
+  function checkArrayExpression (node) {
+    node.elements.forEach(item => {
+      if (item.type === 'Literal') {
+        checkUsedNames(item.value, item)
+      }
+    })
+  }
+
+  function checkObjectExpression (node) {
+    node.properties.forEach(item => {
+      if (item.type === 'Property' && item.key.type === 'Identifier') {
+        checkUsedNames(item.key.name, item.key)
+      }
+    })
+  }
+
+  function checkFunctionExpression (node) {
+    if (node.body.type === 'BlockStatement') {
+      node.body.body.forEach(item => {
+        if (item.type === 'ReturnStatement' && item.argument.type === 'ObjectExpression') {
+          checkObjectExpression(item.argument)
+        }
+      })
+    }
+  }
+
+  // ----------------------------------------------------------------------
+  // Public
+  // ----------------------------------------------------------------------
+
+  return utils.executeOnVueComponent(context, (obj) => {
+    obj.properties
+      .filter(p => p.type === 'Property' && p.key.type === 'Identifier' && scopeNames.has(p.key.name))
+      .forEach(node => {
+        if (node.value.type === 'ArrayExpression') {
+          checkArrayExpression(node.value)
+        } else if (node.value.type === 'ObjectExpression') {
+          checkObjectExpression(node.value)
+        } else if (node.value.type === 'FunctionExpression') {
+          checkFunctionExpression(node.value)
+        }
+      })
+  })
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Prevent duplicate field names',
+      category: 'Possible Errors',
+      recommended: false
+    },
+    fixable: null,  // or "code" or "whitespace"
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          reserved: {
+            type: 'array'
+          },
+          scope: {
+            type: 'array'
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+
+  create
+}

lib/utils/vue-reserved.json

@@ -0,0 +1,4 @@
+[
+  "$data", "$props", "$el", "$options", "$parent", "$root", "$children", "$slots", "$scopedSlots", "$refs", "$isServer", "$attrs", "$listeners",
+  "$watch", "$set", "$delete", "$on", "$once", "$off", "$emit", "$mount", "$forceUpdate", "$nextTick", "$destroy"
+]