Add unit test for getPropsProperties

.gitignore

@@ -1,4 +1,5 @@
 .idea
+*.iml
 /.nyc_output
 /coverage
 /tests/integrations/*/node_modules

lib/rules/prop-name-casing.js

@@ -37,6 +37,7 @@ function create (context) {
 
   return utils.executeOnVue(context, (obj) => {
     const items = utils.getPropsProperties(obj)
+      .props
       .filter(cp => cp.key.type === 'Literal' || (cp.key.type === 'Identifier' && !cp.node.computed))
 
     for (const item of items) {

lib/rules/require-default-prop.js

@@ -21,7 +21,7 @@ module.exports = {
     schema: []
   },
 
-  create: function (context) {
+  create (context) {
     // ----------------------------------------------------------------------
     // Helpers
     // ----------------------------------------------------------------------

lib/rules/require-prop-type-constructor.js

@@ -71,6 +71,7 @@ module.exports = {
 
     return utils.executeOnVueComponent(context, (obj) => {
       const properties = utils.getPropsProperties(obj)
+        .props
         .filter(cp => cp.value)
 
       for (const p of properties) {

lib/rules/require-prop-types.js

@@ -72,8 +72,15 @@ module.exports = {
     return utils.executeOnVue(context, (obj) => {
       const properties = utils.getPropsProperties(obj)
 
-      for (const cp of properties) {
-        checkProperty(cp.key, cp.value, cp.node)
+      if (properties.type === 'ArrayExpression') {
+        context.report({
+          node: properties.node,
+          message: 'Props should at least define their types.'
+        })
+      } else {
+        for (const cp of properties.props) {
+          checkProperty(cp.key, cp.value, cp.node)
+        }
       }
     })
   }

lib/rules/require-valid-default-prop.js

@@ -89,6 +89,7 @@ module.exports = {
 
     return utils.executeOnVue(context, obj => {
       const properties = utils.getPropsProperties(obj)
+        .props
         .filter(cp => cp.value && cp.value.type === 'ObjectExpression')
 
       for (const prop of properties) {

lib/utils/index.js

@@ -367,8 +367,8 @@ module.exports = {
 
   /**
    * Get all props by looking at all component's properties
-   * @param {ObjectExpression} Object with component definition
-   * @return {Array<{key: ASTNode, value: ASTNode | null, node: ASTNode}>} Array of props in format:
+   * @param {ObjectExpression} componentObject Object with component definition
+   * @return {Object} Array of props in format: { node: ASTNode, type: string, props: Array<{key: ASTNode, value: ASTNode | null, node: ASTNode}> }
    */
   getPropsProperties (componentObject) {
     const propsNode = componentObject.properties
@@ -379,7 +379,13 @@ module.exports = {
         (p.value.type === 'ObjectExpression' || p.value.type === 'ArrayExpression')
       )
 
-    if (!propsNode) { return [] }
+    if (!propsNode) {
+      return {
+        node: null,
+        type: null,
+        props: []
+      }
+    }
 
     let props
 
@@ -397,12 +403,16 @@ module.exports = {
         })
     }
 
-    return props
+    return {
+      node: propsNode,
+      type: propsNode.value.type,
+      props: props
+    }
   },
 
   /**
    * Get all computed properties by looking at all component's properties
-   * @param {ObjectExpression} Object with component definition
+   * @param {ObjectExpression} componentObject Object with component definition
    * @return {Array} Array of computed properties in format: [{key: String, value: ASTNode}]
    */
   getComputedProperties (componentObject) {

tests/lib/rules/require-prop-types.js

@@ -154,7 +154,7 @@ ruleTester.run('require-prop-types', rule, {
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       errors: [{
-        message: 'Prop "foo" should define at least its type.',
+        message: 'Props should at least define their types.',
         line: 3
       }]
     },
@@ -167,7 +167,7 @@ ruleTester.run('require-prop-types', rule, {
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       errors: [{
-        message: 'Prop "foo" should define at least its type.',
+        message: 'Props should at least define their types.',
         line: 3
       }]
     },

tests/lib/utils/index.js

@@ -247,3 +247,81 @@ describe('getRegisteredComponents', () => {
     )
   })
 })
+
+describe('getComputedProperties', () => {
+  let node
+
+  const parse = function (code) {
+    const data = babelEslint.parse(code).body[0].declarations[0].init
+    return utils.getPropsProperties(data)
+  }
+
+  it('should return empty array when there is no props property', () => {
+    node = parse(`const test = {
+      name: 'test',
+      data() {
+        return {}
+      }
+    }`)
+
+    assert.notOk(node.type)
+    assert.notOk(node.node)
+    assert.equal(node.props.length,0)
+  })
+
+  it('should return computed props', () => {
+    node = parse(`const test = {
+      name: 'test',
+      data() {
+        return {}
+      },
+      props: {
+        ...foo,
+        a: String,
+        b: {},
+        c: [String],
+        d
+      }
+    }`)
+
+    assert.ok(node.node)
+    assert.equal(node.type, 'ObjectExpression', 'it detects correct type')
+    assert.equal(node.props.length, 4, 'it detects all props' )
+
+    assert.ok(node.props[0].value)
+    assert.ok(node.props[0].key.type === 'Identifier')
+    assert.ok(node.props[0].node.type === 'Property')
+    assert.ok(node.props[0].value.type === 'Identifier')
+
+    assert.ok(node.props[1].value)
+    assert.ok(node.props[1].key.type === 'Identifier')
+    assert.ok(node.props[1].node.type === 'Property')
+    assert.ok(node.props[1].value.type === 'ObjectExpression')
+
+    assert.ok(node.props[2].value)
+    assert.ok(node.props[2].key.type === 'Identifier')
+    assert.ok(node.props[2].node.type === 'Property')
+    assert.ok(node.props[2].value.type === 'ArrayExpression')
+
+    assert.ok(node.props[3].value)
+    assert.ok(node.props[3].key.type === node.props[3].value.type)
+    assert.ok(node.props[3].node.type === 'Property')
+  })
+
+  it('should return computed from array props', () => {
+    node = parse(`const test = {
+      name: 'test',
+      data() {
+        return {}
+      },
+      props: ['a', b, \`c\`, null]
+    }`)
+
+    assert.ok(node.node)
+    assert.equal(node.type, 'ArrayExpression', 'it detects correct type')
+    assert.equal(node.props.length, 1, 'it detects all props' )
+
+    assert.notOk(node.props[0].value)
+    assert.ok(node.props[0].key.type === 'Literal')
+  })
+})