reorganize

Author: jonschlinkert

index.js

@@ -1,12 +1,10 @@
 'use strict';
 
-// require('time-require');
-const assign = Object.assign;
 const Emitter = require('events');
 const extract = require('extract-comments');
 const tokenize = require('tokenize-comment');
-const { expects, allows, format, validate, normalize, utils, parse } = require('./lib');
-const { typeOf, get, set } = utils;
+const lib = require('./lib');
+const { utils } = lib;
 
 /**
  * Create an instance of `Comments` with the given `options`.
@@ -19,7 +17,7 @@ const { typeOf, get, set } = utils;
 class Comments extends Emitter {
   constructor(options) {
     super();
-    this.options = assign({}, options);
+    this.options = Object.assign({}, options);
     this.comments = [];
     this.ast = {};
     this.cache = {
@@ -235,7 +233,7 @@ class Comments extends Emitter {
    */
 
   tokenize(str, options) {
-    return tokenize(str, assign({}, this.options, options));
+    return tokenize(str, Object.assign({}, this.options, options));
   }
 
   /**
@@ -272,8 +270,8 @@ class Comments extends Emitter {
    */
 
   parseComment(comment, options) {
-    const opts = assign({}, this.options, options);
-    const parsers = assign({}, this.plugins.middleware, opts.parse);
+    const opts = Object.assign({}, this.options, options);
+    const parsers = Object.assign({}, this.plugins.middleware, opts.parse);
 
     if (typeof parsers.comment === 'function') {
       comment = parsers.comment.call(this, comment, opts);
@@ -285,8 +283,8 @@ class Comments extends Emitter {
       let tok = this.tokenize(comment.value, opts);
       this.tokens.push(tok);
 
-      comment = assign({}, comment, tok);
-      normalize.examples(comment, opts);
+      comment = Object.assign({}, comment, tok);
+      lib.normalize.examples(comment, opts);
       comment.tags = this.parseTags(comment, options);
 
       // let name = get(comment, 'code.context.name');
@@ -306,7 +304,7 @@ class Comments extends Emitter {
 
     // optionally format comment object
     if (opts.format === true) {
-      comment = format.call(this, comment, opts);
+      comment = lib.format.call(this, comment, opts);
     }
 
     this.emit('comment', comment);
@@ -330,8 +328,8 @@ class Comments extends Emitter {
    */
 
   parseTags(comment, options) {
-    let opts = assign({}, this.options, options);
-    let parsers = assign({}, this.plugins.middleware, opts.parse);
+    let opts = Object.assign({}, this.options, options);
+    let parsers = Object.assign({}, this.plugins.middleware, opts.parse);
     let tags = [];
 
     if (typeof parsers.parseTags === 'function') {
@@ -366,8 +364,8 @@ class Comments extends Emitter {
    */
 
   parseTag(tok, options) {
-    const opts = assign({}, this.options, options);
-    const parsers = assign({}, this.plugins.middleware, opts.parse);
+    const opts = Object.assign({}, this.options, options);
+    const parsers = Object.assign({}, this.plugins.middleware, opts.parse);
     let tag;
 
     if (typeof tok === 'string') {
@@ -379,33 +377,33 @@ class Comments extends Emitter {
     }
 
     try {
-      tag = parse.tag(tok);
+      tag = lib.parse.tag(tok);
     } catch (err) {
       if (opts.strict) throw err;
       return null;
     }
 
-    if (!tag || tag.rawType && !allows.type(tok)) {
+    if (!tag || tag.rawType && !lib.allows.type(tok)) {
       return null;
     }
 
     if (tag.rawType) {
       tag.type = this.parseType(tag.rawType.slice(1, -1), tag, options);
     }
 
-    if (tag && expects.type(tag) && !tag.type) {
+    if (tag && lib.expects.type(tag) && !tag.type) {
       if (opts.strict === true) {
         return null;
       }
       tag.type = null;
     }
 
-    tag = normalize.tag(tag, opts);
+    tag = lib.normalize.tag(tag, opts);
     if (!tag) {
       return null;
     }
 
-    tag = validate.tag(tag, opts);
+    tag = lib.validate.tag(tag, opts);
     if (!tag) {
       return null;
     }
@@ -453,7 +451,7 @@ class Comments extends Emitter {
       return parsers.inlineTag.call(this, str, opts);
     }
 
-    return parse.inline(str, opts);
+    return lib.parse.inline(str, opts);
   }
 
   /**
@@ -482,8 +480,8 @@ class Comments extends Emitter {
       return parsers.type.call(this, str, tag, opts);
     }
 
-    return parse.type(str, tag, opts);
-  };
+    return lib.parse.type(str, tag, opts);
+  }
 
   parseParamType(str, options) {
     if (typeof str !== 'string') {
@@ -514,11 +512,11 @@ class Comments extends Emitter {
     }
 
     let comments = [];
-    const opts = assign({}, this.options, options);
+    const opts = Object.assign({}, this.options, options);
     const res = [];
 
     if (typeof opts.extract === 'function') {
-      comments = utils.arrayify(opts.extract.call(this, str, opts));
+      comments = [].concat(opts.extract.call(this, str, opts) || []);
     } else {
       comments = extract.block(str, opts);
     }
@@ -531,8 +529,6 @@ class Comments extends Emitter {
       let comment = this.preprocess(comments[i], options);
       if (typeof fn === 'function') {
         comment = fn.call(this, comment) || comment;
-      } else {
-        comment = comment;
       }
 
       res.push(comment);
@@ -542,7 +538,7 @@ class Comments extends Emitter {
   }
 
   preprocess(comment, options) {
-    let opts = assign({}, this.options, options);
+    let opts = Object.assign({}, this.options, options);
 
     if (typeof opts.preprocess === 'function') {
       return opts.preprocess.call(this, comment, opts);
@@ -571,7 +567,7 @@ class Comments extends Emitter {
       throw new TypeError('expected comment to be an object');
     }
 
-    let opts = assign({}, this.options, options);
+    let opts = Object.assign({}, this.options, options);
     if (typeof opts.isValid === 'function') {
       return opts.isValid(comment);
     }

lib/format.js renamed to lib/format/format.js

@@ -2,9 +2,13 @@
 
 const Schema = require('map-schema');
 const inflection = require('inflection');
-const normalize = require('./normalize');
-const utils = require('./utils');
-const pluralize = str => inflection.pluralize(str);
+const normalize = require('../normalize');
+const utils = require('../utils');
+
+const nameCache = {};
+const pluralize = name => {
+  return nameCache[name] || (nameCache[name] = inflection.pluralize(name));
+};
 
 function formatType(type, tag, comment) {
   tag.types = tag.types || [];

lib/format/formatter.js

@@ -0,0 +1,41 @@
+'use strict';
+
+class Formatter {
+  constructor() {
+    this.rules = {};
+  }
+
+  rule(name, rule) {
+    this.rules[name] = this.rules[name] || [];
+    this.rules[name].push(rule);
+    return this;
+  }
+
+  run(name, comment) {
+    this.rules[name].forEach(rule => rule(comment));
+    return comment;
+  }
+
+  format(comment) {
+    Object.keys(this.rules).forEach(name => this.run(name, comment));
+    return comment;
+  }
+}
+
+module.exports = Formatter;
+
+const formatter = new Formatter();
+const set = (key, value) => comment => (comment[key] = value);
+
+formatter.rule('foo', set('a', true));
+formatter.rule('foo', set('b', true));
+formatter.rule('foo', set('c', true));
+formatter.rule('foo', set('d', true));
+formatter.rule('foo', set('e', true));
+formatter.rule('bar', set('x', false));
+formatter.rule('bar', set('y', false));
+formatter.rule('bar', set('z', false));
+
+const comment = { foo: {} };
+formatter.format(comment);
+console.log(comment);

lib/formatter.js

@@ -1,15 +1,23 @@
 'use strict';
 
-define('allows', () => require('./allows'));
-define('expects', () => require('./expects'));
+// normalization
+define('normalize', () => require('./normalize'));
+
+// formatting
 define('format', () => require('./format'));
 define('format1', () => require('./format1'));
 define('formatter', () => require('./formatter'));
-define('normalize', () => require('./normalize'));
+
+// parsing
 define('parse', () => require('./parse'));
-define('parser', () => require('./parser'));
-define('utils', () => require('./utils'));
+
+// validation
 define('validate', () => require('./validate'));
+define('allows', () => require('./validate/allows'));
+define('expects', () => require('./validate/expects'));
+
+// utils
+define('utils', () => require('./utils'));
 
 function define(key, get) {
   Reflect.defineProperty(exports, key, { get });

lib/index.js

@@ -1,9 +1,9 @@
 'use strict';
 
 const normalize = module.exports;
-const parseName = require('./parse/name');
-const allows = require('./allows');
-const utils = require('./utils');
+const parseName = require('../parse/name');
+const allows = require('../validate/allows');
+const utils = require('../utils');
 const { isNumber, define, get } = utils;
 
 /**

lib/normalize.js renamed to lib/normalize/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Expression = require('../nodes/expression');
+const Expression = require('./nodes/expression');
 const utils = require('../utils');
 
 module.exports = (tok, options = {}) => {

lib/parse/name.js

@@ -1,9 +1,8 @@
 'use strict';
 
 const Node = require('snapdragon-node');
-const flags = require('../parse/flags');
-const utils = require('../utils');
-const { isNumber, define } = utils;
+const flags = require('../flags');
+const { clean, define, isNumber } = require('../../utils');
 
 class Expression extends Node {
   constructor(name, type) {
@@ -51,7 +50,7 @@ class Expression extends Node {
         break;
       default: {
         this.type = 'NameExpression';
-        this.name = name ? utils.clean(name) : null;
+        this.name = name ? clean(name) : null;
         define(this, 'value', this.name);
 
         let tok = flags(this);