Add unit-test, inference for ES5 classes

Author: ShukantPal

packages/webdoc-parser/src/symbols-babel/extract-symbol.js

@@ -55,6 +55,7 @@ import {
   extractReturns,
   extractType,
 } from "./extract-metadata";
+import type {DataType} from "@webdoc/types";
 import {createSimpleKeywordType} from "@webdoc/model";
 
 // + Extract the symbol name, type from the Node
@@ -115,32 +116,13 @@ export default function extractSymbol(
     nodeSymbol.meta.scope = node.static ? "static" : "instance";
     nodeSymbol.meta.type = "PropertyDoc";
 
-    if (isLiteral(node.value)) {
-      if (isStringLiteral(node.value)) {
-        // Quotes for strings
-        nodeSymbol.meta.defaultValue = `"${node.value.value}"`;
+    const [defaultValue, dataType] = resolveDefaultValue(node.value);
 
-        if (!nodeSymbol.meta.dataType) {
-          nodeSymbol.meta.dataType = createSimpleKeywordType("string");
-        }
-      } else {
-        nodeSymbol.meta.defaultValue = `${node.value.value}`;
+    if (typeof defaultValue === "string") {
+      nodeSymbol.meta.defaultValue = defaultValue;
 
-        if (!nodeSymbol.meta.dataType && isNumericLiteral(node.value)) {
-          nodeSymbol.meta.dataType = createSimpleKeywordType("number");
-        } else if (!nodeSymbol.meta.dataType && isBooleanLiteral(node.value)) {
-          nodeSymbol.meta.dataType = createSimpleKeywordType("boolean");
-        }
-      }
-    } else if (isExpression(node.value)) {
-      const defaultValue = resolveExpression(node.value);
-
-      if (typeof defaultValue === "string") {
-        nodeSymbol.meta.defaultValue = defaultValue;
-
-        if (!isNaN(parseFloat(defaultValue))) {
-          nodeSymbol.meta.dataType = createSimpleKeywordType("number");
-        }
+      if (!nodeSymbol.meta.dataType) {
+        nodeSymbol.meta.dataType = dataType;
       }
     }
   } else if (isClassDeclaration(node) || isClassExpression(node)) {
@@ -229,6 +211,14 @@ export default function extractSymbol(
         nodeSymbol.meta.type = "PropertyDoc";
       }
 
+      // Resolve property default
+      if (!isInit && init) {
+        const [defaultValue, dataType] = resolveDefaultValue(init);
+
+        nodeSymbol.meta.defaultValue = defaultValue;
+        nodeSymbol.meta.dataType = dataType;
+      }
+
       let isExpression = false;
 
       if (isExpressionStatement(node)) {
@@ -424,6 +414,38 @@ function resolveExpression(expression: BabelNodeExpression): string | void {
   }
 }
 
+function resolveDefaultValue(node: BabelNodeExpression): [?string, ?DataType] {
+  let defaultValue: ?string;
+  let dataType: ?DataType;
+
+  if (isLiteral(node)) {
+    if (isStringLiteral(node)) {
+      // Quotes for strings
+      defaultValue = `"${node.value}"`;
+
+      dataType = createSimpleKeywordType("string");
+    } else {
+      defaultValue = `${node.value}`;
+
+      if (isNumericLiteral(node)) {
+        dataType = createSimpleKeywordType("number");
+      } else if (isBooleanLiteral(node)) {
+        dataType = createSimpleKeywordType("boolean");
+      }
+    }
+  } else if (isExpression(node)) {
+    defaultValue = resolveExpression(node);
+
+    if (typeof defaultValue === "string") {
+      if (!isNaN(parseFloat(defaultValue))) {
+        dataType = createSimpleKeywordType("number");
+      }
+    }
+  }
+
+  return [defaultValue, dataType];
+}
+
 // Whether the member expression assigns to this, e.g.
 // this.member.inside.deep -> true
 // top.inside -> false

packages/webdoc-parser/test/lang-ts.js

@@ -47,7 +47,7 @@ describe("@webdoc/parser.LanguageIntegration{@lang ts}", function() {
     expect(symbolInitProperty.meta.dataType).to.not.equal(undefined);
     expect(symbolInitProperty.meta.dataType[0]).to.equal("number");
     expect(symbolInitProperty.meta.access).to.equal("private");
-    expect(symbolInitProperty.meta.defaultValue).to.equal("-11");
+    expect(symbolInitProperty.meta.defaultValue).to.equal("9");
     expect(symbolInitProperty.comment).to.not.equal("");
     expect(symbolInitProperty.meta.readonly).to.equal(true);
   });

packages/webdoc-parser/test/parse-es5-class.js

@@ -1,7 +1,58 @@
+const {findDoc} = require("@webdoc/model");
 const {parse} = require("../lib/parse");
 
+const expect = require("chai").expect;
+
 describe("@webdoc/parser.parse (ES5 classes)", function() {
   it("should correctly infer ES5 classes", function() {
+    const docTree = parse(`      
+      /**
+       * ES5 constructor
+       * @classdesc
+       * Example ES5 class
+       * @class
+       */
+      function ES5Class() {
+      }
+
+      /** ES5 method (ironic arrow fn) */      
+      ES5Class.prototype.es5Method = () => {};
+      
+      /** ES5 static method */
+      ES5Class.es5StaticMethod = function() {};
+      
+      /** ES5 property */
+      ES5Class.prototype.es5Property = "value";
+      
+      /** ES5 static property */
+      ES5Class.es5StaticProperty = "static-value";
+    `);
+
+    const es5Class = findDoc("ES5Class", docTree);
+    const es5Constructor = findDoc("ES5Class.constructor", docTree);
+
+    expect(es5Class.description).to.not.include("ES5 constructor");
+    expect(es5Class.description).to.include("ES5 class");
+    expect(es5Constructor.description).to.not.include("ES5 class");
+    expect(es5Constructor.description).to.include("ES5 constructor");
+
+    const es5Method = findDoc("ES5Class.es5Method", docTree);
+    const es5StaticMethod = findDoc("ES5Class.es5StaticMethod", docTree);
+    const es5Property = findDoc("ES5Class.es5Property", docTree);
+    const es5StaticProperty = findDoc("ES5Class.es5StaticProperty", docTree);
+
+    expect(es5Method.scope).to.equal("instance");
+    expect(es5Method.type).to.equal("MethodDoc");
+
+    expect(es5StaticMethod.scope).to.equal("static");
+    expect(es5StaticMethod.type).to.equal("MethodDoc");
+
+    expect(es5Property.defaultValue).to.equal("\"value\"");
+    expect(es5Property.scope).to.equal("instance");
+    expect(es5Property.type).to.equal("PropertyDoc");
 
-  })
+    expect(es5StaticProperty.defaultValue).to.equal("\"static-value\"");
+    expect(es5StaticProperty.scope).to.equal("static");
+    expect(es5StaticProperty.type).to.equal("PropertyDoc");
+  });
 });

packages/webdoc-parser/test/parse-ts.js

@@ -21,7 +21,7 @@ describe("@webdoc/parser.parse (Typescript)", function() {
     }]);
 
     expect(docs.members.length).to.equal(1);
-    expect(docs.members[0].members.length).to.equal(1);
+    expect(docs.members[0].members.length).to.be.gte(1);
 
     const fieldDoc = docs.members[0].members[0];