Adding support for module.exports in vue files

lib/parser.js

@@ -212,56 +212,62 @@ class Parser extends EventEmitter {
     this.eventsEmmited = {}
   }
 
+  extractProperties (property) {
+            switch (property.value.type) {
+              case 'ObjectExpression':
+                property.value.properties.forEach((p) => {
+                  const entry = getComment(p)
+
+                  entry.value = value(p)
+                  entry.name = Object.keys(entry.value)[0]
+                  entry.value = entry.value[entry.name]
+
+                  if (entry.value instanceof NodeFunction) {
+                    entry.params = entry.value.params
+                  } else if (property.key.name === 'props') {
+                    if (entry.describeModel) {
+                      entry.name = 'v-model'
+                    } else {
+                      entry.name = unCamelcase(entry.name)
+                    }
+                  }
+
+                  delete entry.describeModel
+
+                  this.emit(property.key.name, entry)
+                  this.subWalk(entry.value)
+                })
+                break
+
+              default:
+                const propertyValue = value(property)
+                const entryValue = first(propertyValue)
+
+                if (propertyValue.hasOwnProperty('name') && !this.componentName) {
+                  this.componentName = propertyValue.name
+                  break
+                }
+
+                this.subWalk(entryValue)
+            }
+  }
+
   walk () {
     process.nextTick(() => {
       this.ast.body.forEach((body) => {
-        if (body.type !== 'ExportDefaultDeclaration') {
+        if (body.type !== 'ExportDefaultDeclaration' && body.type !== 'ExpressionStatement') {
           const entry = getComment(body)
           const description = entry ? entry.description : null
 
           this.emit('description', description)
           return
         }
 
-        body.declaration.properties.forEach((property) => {
-          switch (property.value.type) {
-            case 'ObjectExpression':
-              property.value.properties.forEach((p) => {
-                const entry = getComment(p)
-
-                entry.value = value(p)
-                entry.name = Object.keys(entry.value)[0]
-                entry.value = entry.value[entry.name]
-
-                if (entry.value instanceof NodeFunction) {
-                  entry.params = entry.value.params
-                } else if (property.key.name === 'props') {
-                  if (entry.describeModel) {
-                    entry.name = 'v-model'
-                  } else {
-                    entry.name = unCamelcase(entry.name)
-                  }
-                }
-
-                delete entry.describeModel
-
-                this.emit(property.key.name, entry)
-                this.subWalk(entry.value)
-              })
-              break
-
-            default:
-              const propertyValue = value(property)
-              const entryValue = first(propertyValue)
-
-              if (propertyValue.hasOwnProperty('name') && !this.componentName) {
-                this.componentName = propertyValue.name
-                break
-              }
-
-              this.subWalk(entryValue)
-          }
-        })
+        if (body.declaration != null) {
+          body.declaration.properties.forEach((property) => this.extractProperties(property))
+        } else if (body.expression != null) {
+          body.expression.right.properties.forEach((property) => this.extractProperties(property))
+        }
 
         if (this.componentName === null && this.filename) {
           const filename = path.parse(this.filename).name

test/fixtures/checkboxModuleExports.vue

@@ -0,0 +1,139 @@
+<template>
+  <label>
+    <input :disabled="disabled" type="text" v-model="checkbox">
+    <!-- Default slot -->
+    <slot></slot>
+    <!-- Use this slot to set the checkbox label -->
+    <slot name="label">Unamed checkbox</slot>
+    <!-- 
+      This
+      is multiline description
+    -->
+    <slot name="multiline">Unamed checkbox</slot>
+    <slot name="undescribed"></slot>
+    <template></template>
+  </label>
+</template>
+
+<script>
+const dynamic2 = 'dynamicMode'
+
+/**
+ * A simple checkbox component
+ */
+module.exports = {
+  name: 'checkbox',
+  props: {
+    /**
+     * The checkbox model
+     * @model
+     */
+    model: {
+      type: Array,
+      required: true,
+      twoWay: true
+    },
+
+    /** 
+     * Initial checkbox state
+     */
+    disabled: Boolean,
+
+    /**
+     * Initial checkbox value
+     */
+    checked: {
+      type: Boolean,
+      default: true
+    },
+
+    // Prop with camel name
+    propWithCamel: {
+      type: Object,
+      default: () => ({ name: 'X'})
+    }
+  },
+
+  data () {
+    return {}
+  },
+
+  created () {
+    /**
+     * Emit when the component has been loaded
+     */
+    this.$emit('loaded')
+  },
+
+  methods: {
+    /**
+     * @private
+     */
+    privateMethod () {
+      console.log('check')
+
+      const name = 'check'
+      const value = 'event value'
+
+      if (name) {
+        console.log('>', name)
+      }
+
+      /**
+       * Event with identifier name
+       */
+      this.$emit(name, value)
+    },
+
+    /**
+     * Check the checkbox
+     */
+    check () {
+      console.log('check')
+
+      let eventName = 'check'
+      const value = 'event value'
+
+      if (eventName) {
+        console.log('>', eventName)
+      }
+
+      eventName = 'renamed'
+
+      /**
+       * Event with renamed identifier name
+       */
+      this.$emit(eventName, value)
+    },
+
+    /**
+     * @protected
+     */
+    recursiveIdentifierValue () {
+      console.log('check')
+
+      let recursiveValue = 'recursive'
+      const value = 'event value'
+
+      if (eventName) {
+        console.log('>', eventName)
+      }
+
+      eventName = recursiveValue
+
+      /**
+       * Event with recursive identifier name
+       */
+      this.$emit(eventName, value)
+    },
+
+    uncommentedMethod () {}
+  }
+}
+</script>
+
+<style lang="css" scoped>
+label {
+  font-size: .9em
+}
+</style>

test/parser.spec.js

@@ -12,10 +12,16 @@ const options = {
   ignoredVisibilities: []
 }
 
+const optionsForModuleExports = {
+  filename: f('checkboxModuleExports.vue'),
+  encoding: 'utf8',
+  ignoredVisibilities: []
+}
+
 /* global describe it */
 
 describe('options', () => {
-  it('should faild to parse with missing options.filename', (done) => {
+  it('should fail to parse with missing options.filename', (done) => {
     parser.parse({})
       .catch((err) => {
         assert.ok(/required/.test(err.message))
@@ -35,7 +41,7 @@ describe('options', () => {
       .catch(done)
   })
 
-  it('should faild with missing options.filename', (done) => {
+  it('should fail with missing options.filename', (done) => {
     parser.parse({})
       .catch((err) => {
         assert.ok(/required/.test(err.message))
@@ -44,11 +50,15 @@ describe('options', () => {
   })
 })
 
-describe('component', () => {
+describe('component', () => testComponent(options))
+
+describe('component_module.exports', () => testComponent(optionsForModuleExports))
+
+function testComponent(optionsToParse) {
   let component = {}
 
   it('should parse without error', (done) => {
-    parser.parse(options)
+    parser.parse(optionsToParse)
       .then((_component) => {
         component = _component
         done()
@@ -70,12 +80,16 @@ describe('component', () => {
 
   it('should have a description', () =>
     assert.equal(component.description, 'A simple checkbox component'))
-})
+}
+
+describe('component.props', () => testComponentProps(options))
+
+describe('component.props_module.exports', () => testComponentProps(optionsForModuleExports))
 
-describe('component.props', () => {
+function testComponentProps(optionsToParse) {
   let component = {}
 
-  parser.parse(options)
+  parser.parse(optionsToParse)
     .then((_component) => (component = _component))
     .catch((err) => { throw err })
 
@@ -114,9 +128,13 @@ describe('component.props', () => {
     assert.equal(item.value.default.type, 'ArrowFunctionExpression')
     assert.equal(item.description, 'Prop with camel name')
   })
-})
+}
 
-describe('component.slots', () => {
+describe('component.slots', () => testComponentSlots(options))
+
+describe('component.slots_module.exports', () => testComponentSlots(optionsForModuleExports))
+
+function testComponentSlots(optionsToParse) {
   let component = {}
 
   parser.parse(options)
@@ -154,9 +172,13 @@ describe('component.slots', () => {
     assert.notEqual(typeof item, 'undefined')
     assert.equal(item.description, null)
   })
-})
+}
+
+describe('component.events', () => testComponentEvents(options))
+
+describe('component.events_module.exports', () => testComponentEvents(optionsForModuleExports))
 
-describe('component.events', () => {
+function testComponentEvents(optionsToParse) {
   let component = {}
 
   parser.parse(options)
@@ -190,9 +212,13 @@ describe('component.events', () => {
     assert.notEqual(typeof item, 'undefined')
     assert.equal(item.description, 'Event with recursive identifier name')
   })
-})
+}
+
+describe('component.methods', () => testComponentMethods(options))
 
-describe('component.methods', () => {
+describe('component.methods_module.exports', () => testComponentMethods(optionsForModuleExports))
+
+function testComponentMethods(optionsToParse) {
   let component = {}
 
   parser.parse(options)
@@ -229,4 +255,4 @@ describe('component.methods', () => {
 
     assert.notEqual(typeof item, 'undefined')
   })
-})
+}