update package

Author: Mpdreamz

specification/src/api-specification.ts

@@ -37,9 +37,9 @@ export class Specification {
     const specVisitor = new TypeReader(this.program)
     const types = [].concat(specVisitor.interfaces).concat(specVisitor.enums)
     // resolve inherits by creating the proper pointers to instances, pretty hairy but it works
-    const dictTypes = types.reduce((o, p) => ({ ...o, [p.name]: p }), {}) as TypeDictionary
-    const stringType = new Domain.Interface('string')
-    const lookup = (key: string) => key === 'string' ? stringType : (dictTypes[key] as Domain.Interface)
+    const dictTypes = types.reduce((o, p) => ({...o, [p.name]: p}), {}) as TypeDictionary;
+    const stringType = new Domain.Interface("string" , "internal");
+    const lookup = (key: string) => key === "string" ? stringType : (dictTypes[key] as Domain.Interface);
     types.forEach(t => {
       if (!(t instanceof Domain.Interface)) return
       t.inherits = []

specification/src/domain.ts

@@ -6,6 +6,7 @@ namespace Domain {
   export class Type {
     constructor (public name: string) {}
     nullable: boolean;
+    closedGenerics: InstanceOf[] = [];
   }
   export class ArrayOf {
     type = new Type('array');
@@ -23,7 +24,7 @@ namespace Domain {
   export type InstanceOf = Type|ArrayOf|Dictionary|UnionOf;
 
   export class TypeDeclaration {
-    constructor (public name: string) {}
+    constructor(public name: string, public namespace: string) {}
   }
 
   export class Interface extends TypeDeclaration {
@@ -45,12 +46,12 @@ namespace Domain {
   }
 
   export class Enum extends TypeDeclaration {
-    constructor (public name: string, public flags: boolean = false) { super(name) }
+    constructor(public name: string, public namespace: string, public flags: boolean = false) { super(name, namespace); }
     members: EnumMember[] = [];
   }
 
   export class EnumMember {
-    constructor (public name: string) {}
+    constructor(public name: string, public stringRepresentation: string) {}
   }
 
   export class BodyDocumentation {

specification/src/specification/type-reader.ts

@@ -2,18 +2,19 @@ import {RestSpecMapping, RestSpecName, TypeName} from "./rest-spec-mapping";
 import _ from "lodash";
 import * as ts from "byots";
 import Domain = require("../domain");
+import path from "path";
 
 class Visitor {
   constructor(protected checker: ts.TypeChecker) {}
   protected symbolName = (node: ts.Node): string => this.checker.getSymbolAtLocation(node).getName();
 }
 
 class EnumVisitor extends Visitor {
-  constructor(private enumNode: ts.EnumDeclaration, checker: ts.TypeChecker) {super(checker); }
+  constructor(private enumNode: ts.EnumDeclaration, checker: ts.TypeChecker, private namespace: string) {super(checker); }
 
   visit(): Domain.Enum {
     const name = this.symbolName(this.enumNode.name);
-    const domainEnum = new Domain.Enum(name);
+    const domainEnum = new Domain.Enum(name, this.namespace);
     for (const child of this.enumNode.getChildren())
       this.visitMember(child as ts.EnumMember, domainEnum);
     return domainEnum;
@@ -30,21 +31,25 @@ class EnumVisitor extends Visitor {
     if (!this.isMember(member, e)) return;
 
     const name = this.symbolName(member.name);
-    e.members.push(new Domain.EnumMember(name));
+    const description = (member.jsDoc || []).map(c => c.comment).join(".").trim();
+
+    e.members.push(new Domain.EnumMember(description || name, name));
   }
 }
 
 class InterfaceVisitor extends Visitor {
   name: TypeName;
   specMapping: RestSpecMapping;
-  constructor(private interfaceNode: ts.InterfaceDeclaration | ts.ClassDeclaration, checker: ts.TypeChecker) {
-    super(checker);
-  }
+
+  constructor(
+    private interfaceNode: ts.InterfaceDeclaration | ts.ClassDeclaration,
+    checker: ts.TypeChecker,
+    private namespace: string) { super(checker); }
 
   visit(): Domain.Interface {
     const n = this.symbolName(this.interfaceNode.name);
     this.name = n;
-    const domainInterface = new Domain.Interface(n);
+    const domainInterface = new Domain.Interface(n, this.namespace);
 
     const decorator = _(this.interfaceNode.decorators || [])
       .map(d => d.expression.getText())
@@ -136,7 +141,11 @@ class InterfaceVisitor extends Visitor {
     const typeName = t.typeName.getText();
     if (typeName.startsWith("Dictionary")) return this.createDictionary(t, typeName);
     if (typeName.startsWith("Union")) return this.createUnion(t, typeName);
-    return new Domain.Type(t.getText());
+    const typed = new Domain.Type(typeName);
+    if (!t.typeArguments || t.typeArguments.length === 0)
+      return typed;
+    typed.closedGenerics = t.typeArguments.map(gt => this.visitTypeNode(gt));
+    return typed;
   }
 
   private createUnion(t: ts.TypeReferenceNode, typeName) {
@@ -187,30 +196,34 @@ export class TypeReader {
     this.restSpecMapping = {};
     this.checker = program.getTypeChecker();
     for (const f of this.program.getSourceFiles()) {
-      if (!f.path.match(/specification\/specs/)) continue;
-      this.visit(f);
+      if (!f.path.match(/specification[\/\\]specs/)) continue;
+      let ns = path.dirname(f.path)
+        .replace(/.*specification[\/\\]specs[\/\\]?/, "")
+        .replace(/[\/\\]/g, ".");
+      if (ns === "") ns = "internal";
+      this.visit(f, ns);
     }
   }
 
-  private visit(node: ts.Node) {
+  private visit(node: ts.Node, namespace: string) {
       switch (node.kind) {
         case ts.SyntaxKind.ClassDeclaration:
-          const cv = new InterfaceVisitor(node as ts.ClassDeclaration, this.checker);
+          const cv = new InterfaceVisitor(node as ts.ClassDeclaration, this.checker, namespace);
           const c = cv.visit();
           if (cv.specMapping) this.restSpecMapping[cv.specMapping.spec] = cv.specMapping;
           this.interfaces.push(c);
           break;
         case ts.SyntaxKind.InterfaceDeclaration:
-          const iv = new InterfaceVisitor(node as ts.InterfaceDeclaration, this.checker);
+          const iv = new InterfaceVisitor(node as ts.InterfaceDeclaration, this.checker, namespace);
           const i = iv.visit();
           this.interfaces.push(i);
           break;
 
         case ts.SyntaxKind.EnumDeclaration:
-          const ev = new EnumVisitor(node as ts.EnumDeclaration, this.checker);
+          const ev = new EnumVisitor(node as ts.EnumDeclaration, this.checker, namespace);
           this.enums.push(ev.visit());
           break;
       }
-      ts.forEachChild(node, c => this.visit(c));
+      ts.forEachChild(node, c => this.visit(c, namespace));
   }
 }