small refactoring of token extracters

Author: ovfireandvoid

__tests__/extractToken.test.js

@@ -27,15 +27,23 @@ describe('extractToken', () => {
         args: [],
       });
 
-      expect(extractToken.extractFunction(class_constructor_line)).toEqual({
+      expect(extractToken.extractFunction(variable_line)).toBeNull();
+      expect(extractToken.extractFunction(class_constructor_line)).toBeNull();
+      expect(extractToken.extractFunction(class_method_line)).toBeNull();
+      expect(extractToken.extractFunction(base_class_line)).toBeNull();
+    });
+
+    it('extracts class', () => {
+      expect(extractToken.extractClass(class_constructor_line)).toEqual({
         type: 'class_constructor',
         class: 'Class',
         args: ['args'],
       });
 
-      expect(extractToken.extractFunction(variable_line)).toBeNull();
-      expect(extractToken.extractFunction(class_method_line)).toBeNull();
-      expect(extractToken.extractFunction(base_class_line)).toBeNull();
+      expect(extractToken.extractClass(variable_line)).toBeNull();
+      expect(extractToken.extractClass(function_line)).toBeNull();
+      expect(extractToken.extractClass(class_method_line)).toBeNull();
+      expect(extractToken.extractClass(base_class_line)).toBeNull();
     });
 
     it('extracts class method', () => {
@@ -113,7 +121,10 @@ describe('extractToken', () => {
       {
         type: 'global_variable',
         name: 'x',
-        comment: { brief: 'Variable description', type: 'String' },
+        comment: {
+          brief: 'Variable description',
+          type: 'String',
+        },
       },
     ]);
 

src/extractToken.js

@@ -4,7 +4,7 @@ const extractVariable = line => {
   const variable_expr = /^var\s+(\w+)/;
   const variable_match = line.match(variable_expr);
   if (variable_match) {
-    const [_, variable_name] = variable_match;
+    const [, variable_name] = variable_match;
     return {
       type: 'global_variable',
       name: variable_name,
@@ -18,20 +18,31 @@ const extractFunction = line => {
   const function_expr = /^function\s+(\w+)\s*\((.*)\)/;
   const function_match = line.match(function_expr);
   if (function_match) {
-    const [_, function_name, function_args] = function_match;
+    const [, function_name, function_args] = function_match;
+    if (!utils.isClassName(function_name)) {
+      return {
+        type: 'global_function',
+        name: function_name,
+        args: utils.argsArray(function_args),
+      };
+    }
+  }
+
+  return null;
+};
+
+const extractClass = line => {
+  const function_expr = /^function\s+(\w+)\s*\((.*)\)/;
+  const function_match = line.match(function_expr);
+  if (function_match) {
+    const [, function_name, function_args] = function_match;
     if (utils.isClassName(function_name)) {
       return {
         type: 'class_constructor',
         class: function_name,
         args: utils.argsArray(function_args),
       };
     }
-
-    return {
-      type: 'global_function',
-      name: function_name,
-      args: utils.argsArray(function_args),
-    };
   }
 
   return null;
@@ -42,7 +53,7 @@ const extractBaseClass = line => {
   const base_class_match = line.match(base_class_expr);
 
   if (base_class_match) {
-    const [_, class_name, base_class_name] = base_class_match;
+    const [, class_name, base_class_name] = base_class_match;
     return {
       type: 'base_class',
       class: class_name,
@@ -57,7 +68,7 @@ const extractClassMethod = line => {
   const class_method_expr = /^(\w+)\.prototype\.(\w+)\s*\=\s*function\((.*)\)/;
   const class_method_match = line.match(class_method_expr);
   if (class_method_match) {
-    const [_, class_name, method_name, method_args] = class_method_match;
+    const [, class_name, method_name, method_args] = class_method_match;
     return {
       type: 'class_method',
       class: class_name,
@@ -75,18 +86,18 @@ const extractComment = comment_array => {
   const param_expr = /^\s*\*\s*@param\s*(type\:(\w+))?\s*(\w+)\s*(.*)$/;
   const return_expr = /^\s*\*\s*@return\s*(type\:(\w+))?\s*(.*)$/;
 
-  return comment_array.reduce((comment, line) => {
+  const comment = comment_array.reduce((comment, line) => {
     const oneliner_match = line.match(oneliner_expr);
     if (oneliner_match) {
-      const [_, __, type, brief] = oneliner_match;
+      const [, , type, brief] = oneliner_match;
       comment.brief = brief;
       comment.type = type;
       return comment;
     }
 
     const brief_match = line.match(brief_expr);
     if (brief_match) {
-      const [_, brief] = brief_match;
+      const [, brief] = brief_match;
       comment.brief = brief;
       return comment;
     }
@@ -96,60 +107,67 @@ const extractComment = comment_array => {
       if (!comment.params) {
         comment.params = {};
       }
-      const [_, __, type, name, brief] = param_match;
+      const [, , type, name, brief] = param_match;
       comment.params[name] = { brief, name, type };
       return comment;
     }
 
     const return_match = line.match(return_expr);
     if (return_match) {
-      const [_, __, type, brief] = return_match;
+      const [, , type, brief] = return_match;
       comment.return = { brief, type };
     }
 
     return comment;
   }, {});
+
+  return comment;
 };
 
 var reading_comment = false;
 var comment_ready = false;
-var comment = [];
+var comment_lines = [];
+var comment = null;
 
 const extractToken = (tokens, line) => {
   if (utils.isSingleLineComment(line)) {
+    comment_lines = [line];
+    comment = extractComment(comment_lines);
     comment_ready = true;
-    comment = [line];
     return tokens;
   }
 
   if (utils.isCommentEnd(line)) {
-    reading_comment = false;
+    comment = extractComment(comment_lines);
     comment_ready = true;
+    reading_comment = false;
     return tokens;
   }
 
   if (reading_comment) {
-    comment.push(line);
+    comment_lines.push(line);
     return tokens;
   }
 
   if (utils.isCommentStart(line)) {
-    reading_comment = true;
+    comment_lines = [];
+    comment = null;
     comment_ready = false;
-    comment = [];
+    reading_comment = true;
 
     return tokens;
   }
 
   var token =
     extractVariable(line) ||
     extractFunction(line) ||
+    extractClass(line) ||
     extractClassMethod(line) ||
     extractBaseClass(line);
 
   if (token) {
     if (comment_ready) {
-      token.comment = extractComment(comment);
+      token.comment = comment;
       comment_ready = false;
     }
 
@@ -163,6 +181,7 @@ exports = module.exports = extractToken;
 
 exports.extractVariable = extractVariable;
 exports.extractFunction = extractFunction;
+exports.extractClass = extractClass;
 exports.extractClassMethod = extractClassMethod;
 exports.extractBaseClass = extractBaseClass;
 exports.extractComment = extractComment;