comment-parser 0.3.2 → 0.5.0

package/tests/custom-parsers.spec.js

@@ -1,139 +1,130 @@
-var fs = require('fs');
-var expect = require('chai').expect;
-var parse = require('../index');
+/* eslint no-unused-vars:off */
+var expect = require('chai').expect
+var parse = require('./parse')
 
-describe('parse() with custom tag parsers', function() {
-
-  function parsed(func, opts) {
-    var str = func.toString();
-    return parse(str.slice(
-      str.indexOf('{') + 1,
-      str.lastIndexOf('}')
-    ).trim(), opts);
-  }
-
-  function sample() {
+describe('parse() with custom tag parsers', function () {
+  function sample () {
     /**
      * @tag {type} name description
      */
-    var a;
+    var a
   }
 
-  it('should use `opts.parsers`', function() {
+  it('should use `opts.parsers`', function () {
     var parsers = [
-      function everything(str) {
+      function everything (str) {
         return {
-          source : str,
-          data   : {
-            tag         : 'tag',
-            type        : 'type',
-            name        : 'name',
-            optional    : false,
-            description : 'description'
+          source: str,
+          data: {
+            tag: 'tag',
+            type: 'type',
+            name: 'name',
+            optional: false,
+            description: 'description'
           }
-        };
+        }
       }
-    ];
+    ]
 
-    expect(parsed(sample, {parsers: parsers})[0])
+    expect(parse(sample, {parsers: parsers})[0])
       .to.eql({
-        line        : 0,
-        description : '',
-        source      : '@tag {type} name description',
+        line: 1,
+        description: '',
+        source: '@tag {type} name description',
         tags: [{
-          tag         : 'tag',
-          type        : 'type',
-          name        : 'name',
-          description : 'description',
-          optional    : false,
-          source      : '@tag {type} name description',
-          line        : 1
+          tag: 'tag',
+          type: 'type',
+          name: 'name',
+          description: 'description',
+          optional: false,
+          source: '@tag {type} name description',
+          line: 2
         }]
-      });
-  });
+      })
+  })
 
-  it('should merge parsers result', function() {
+  it('should merge parsers result', function () {
     var parsers = [
-      function parser1(str) {
+      function parser1 (str) {
         return {
-          source : '',
-          data   : {tag: 'tag'},
-        };
+          source: '',
+          data: {tag: 'tag'}
+        }
       },
-      function parser2(str) {
+      function parser2 (str) {
         return {
-          source : '',
-          data   : {type: 'type'},
-        };
+          source: '',
+          data: {type: 'type'}
+        }
       },
-      function parser3(str) {
+      function parser3 (str) {
         return {
-          source : '',
-          data   : {
-            name        : 'name',
-            description : 'description'
-          },
-        };
+          source: '',
+          data: {
+            name: 'name',
+            description: 'description'
+          }
+        }
       }
-    ];
+    ]
 
-    expect(parsed(sample, {parsers: parsers})[0])
+    expect(parse(sample, {parsers: parsers})[0])
       .to.eql({
-        line        : 0,
-        description : '',
-        source      : '@tag {type} name description',
+        line: 1,
+        description: '',
+        source: '@tag {type} name description',
         tags: [{
-          tag         : 'tag',
-          type        : 'type',
-          name        : 'name',
-          description : 'description',
-          optional    : false,
-          source      : '@tag {type} name description',
-          line        : 1
+          tag: 'tag',
+          type: 'type',
+          name: 'name',
+          description: 'description',
+          optional: false,
+          source: '@tag {type} name description',
+          line: 2
         }]
-      });
-  });
+      })
+  })
 
-  it('should catch parser exceptions and populate `errors` field', function() {
+  it('should catch parser exceptions and populate `errors` field', function () {
     var parsers = [
-      function parser1(str) {
+      function parser1 (str) {
         return {
-          source : '',
-          data   : {tag: 'tag'}
-        };
+          source: '',
+          data: {tag: 'tag'}
+        }
       },
-      function parser2(str) {
-        throw new Error('error 1');
+      function parser2 (str) {
+        throw new Error('error 1')
       },
-      function parser3(str) {
-        throw new Error('error 2');
+      function parser3 (str) {
+        throw new Error('error 2')
       },
-      function parser4(str) {
+      function parser4 (str) {
         return {
-          source : '',
-          data   : {name: 'name'}
-        };
-      },
-    ];
+          source: '',
+          data: {name: 'name'}
+        }
+      }
+    ]
 
-    expect(parsed(sample, {parsers: parsers})[0])
+    expect(parse(sample, {parsers: parsers})[0])
       .to.eql({
-        line        : 0,
-        description : '',
-        source      : '@tag {type} name description',
+        line: 1,
+        description: '',
+        source: '@tag {type} name description',
         tags: [{
-          tag         : 'tag',
-          type        : '',
-          name        : 'name',
-          description : '',
-          optional    : false,
-          source      : '@tag {type} name description',
-          errors      : [
+          tag: 'tag',
+          type: '',
+          name: 'name',
+          description: '',
+          optional: false,
+          source: '@tag {type} name description',
+          errors: [
             'parser2: error 1',
             'parser3: error 2'
           ],
-          line   : 1
+          line: 2
         }]
-      });
-  });
-});
+      })
+  })
+})

package/tests/files.spec.js

@@ -1,56 +1,55 @@
-
-var fs     = require('fs');
-var stream = require('readable-stream');
+/* eslint no-unused-vars:off */
+var fs = require('fs')
+var path = require('path')
+var stream = require('readable-stream')
 var expect = require('chai').expect
-var parse  = require('../index');
-
-describe('File parsing', function() {
-
-  it('should parse the file by path', function(done) {
-      parse.file(__dirname + '/fixtures/sample.js', function(err, parsed) {
-        if (err) { done(err); }
+var parse = require('../index')
 
-        expect(parsed)
-          .to.be.an('array');
+describe('File parsing', function () {
+  it('should parse the file by path', function (done) {
+    parse.file(path.resolve(__dirname, 'fixtures/sample.js'), function (err, parsed) {
+      if (err) { done(err) }
 
-        expect(parsed.length)
-          .to.eq(4);
+      expect(parsed)
+        .to.be.an('array')
 
-        expect(parsed[0].description)
-          .to.eq('File description');
+      expect(parsed.length)
+        .to.eq(4)
 
-        expect(parsed[1].tags[0].tag)
-          .to.eq('class');
+      expect(parsed[0].description)
+        .to.eq('File description')
 
-        expect(parsed[2].tags[0].tag)
-          .to.eq('property');
+      expect(parsed[1].tags[0].tag)
+        .to.eq('class')
 
-        expect(parsed[3].tags[0].tag)
-          .to.eq('method');
+      expect(parsed[2].tags[0].tag)
+        .to.eq('property')
 
-        done();
-      });
-  });
+      expect(parsed[3].tags[0].tag)
+        .to.eq('method')
 
-  it('should path the error if file dows not exist', function(done) {
-      parse.file('does/not/exists', function(err, parsed) {
-        expect(err)
-          .to.be.instanceof(Error);
-        done();
-      });
-  });
+      done()
+    })
+  })
 
-  it('should return `Transform` stream', function(done) {
+  it('should path the error if file dows not exist', function (done) {
+    parse.file('does/not/exists', function (err, parsed) {
+      expect(err)
+        .to.be.instanceof(Error)
+      done()
+    })
+  })
 
-    var count = 0;
+  it('should return `Transform` stream', function (done) {
+    var count = 0
 
-    var readable = fs.createReadStream(__dirname + '/fixtures/sample.js', {encoding: 'utf8'});
+    var readable = fs.createReadStream(path.resolve(__dirname, 'fixtures/sample.js'), {encoding: 'utf8'})
 
-    var writable = new stream.Writable({objectMode: true});
-    writable._write = function(data, encoding, done) {
-        count++;
-        done();
-    };
+    var writable = new stream.Writable({objectMode: true})
+    writable._write = function (data, encoding, done) {
+      count++
+      done()
+    }
 
     readable
       .on('error', done)
@@ -58,11 +57,11 @@ describe('File parsing', function() {
       .on('error', done)
       .pipe(writable)
       .on('error', done)
-      .on('finish', function() {
+      .on('finish', function () {
         expect(count)
-          .to.eq(4);
+          .to.eq(4)
 
-        done();
-      });
-  });
-});
+        done()
+      })
+  })
+})

package/tests/fixtures/sample.js

@@ -10,7 +10,7 @@
  * @param {Int} coords.x
  * @param {Int} coords.y
  */
-function Point(options) {
+function Point (options) {
 
 }
 
@@ -18,19 +18,19 @@ function Point(options) {
  * This should be skipped
  */
 
-    /**
-     * Tells if point was ever initilized with coordinates
-     * @property {Boolean} [initilized=false]
-     */
-    Point.prototype.initilized = false;
+/**
+ * Tells if point was ever initilized with coordinates
+ * @property {Boolean} [initilized=false]
+ */
+Point.prototype.initilized = false
 
-    /**
-     * Moves point by x,y
-     * @method move
-     * @param {Object} [by]
-     * @param {Int} by.x
-     * @param {Int} by.y
-     */
-    Point.prototype.move = function(by) {
+/**
+ * Moves point by x,y
+ * @method move
+ * @param {Object} [by]
+ * @param {Int} by.x
+ * @param {Int} by.y
+ */
+Point.prototype.move = function (by) {
 
-    }
+}

package/tests/parse.js

@@ -0,0 +1,18 @@
+/**
+ * Source lines numeration:
+ *
+ * 0 function() {
+ * 1  // source with comments
+ * 2 }
+ *
+ */
+
+var parse = require('../index')
+
+module.exports = function (func, opts) {
+  var str = func.toString()
+  return parse(str.slice(
+    str.indexOf('{') + 1,
+    str.lastIndexOf('}')
+  ), opts)
+}