feat(parsing): parse object and array destructurings correctly (#76)

.appveyor.yml

@@ -8,8 +8,6 @@ matrix:
 environment:
   matrix:
     - nodejs_version: "10"
-    - nodejs_version: "9"
-    - nodejs_version: "8"
 
 install:
   - ps: Install-Product node $env:nodejs_version
@@ -19,5 +17,6 @@ test_script:
   - npm test
   - npm install -g codecov
   - codecov
+  - npm run build
 
 build: off

src/declarations/ParameterDeclaration.ts

@@ -11,3 +11,41 @@ import { TypedDeclaration } from './Declaration';
 export class ParameterDeclaration implements TypedDeclaration {
     constructor(public name: string, public type: string | undefined, public start?: number, public end?: number) { }
 }
+
+export class BoundParameterDeclaration extends ParameterDeclaration {
+    public parameters: ParameterDeclaration[] = [];
+    public typeReference: string | undefined;
+
+    public get name(): string {
+        return this.parameters.length ?
+            `${this.startCharacter} ${this.parameters.map(p => p.name).join(', ')} ${this.endCharacter}` :
+            this.startCharacter + this.endCharacter;
+    }
+
+    public set name(_: string) { }
+
+    public get type(): string {
+        return this.typeReference ||
+            this.parameters.length ?
+            `{ ${this.parameters.map(p => p.type).join(', ')} }` :
+            this.startCharacter + this.endCharacter;
+    }
+
+    public set type(_: string) { }
+
+    constructor(private startCharacter: string, private endCharacter: string, start?: number, end?: number) {
+        super('', '', start, end);
+    }
+}
+
+export class ObjectBoundParameterDeclaration extends BoundParameterDeclaration {
+    constructor(start?: number, end?: number) {
+        super('{', '}', start, end);
+    }
+}
+
+export class ArrayBoundParameterDeclaration extends BoundParameterDeclaration {
+    constructor(start?: number, end?: number) {
+        super('[', ']', start, end);
+    }
+}

src/node-parser/function-parser.ts

@@ -1,12 +1,14 @@
 import {
-    ArrayBindingPattern,
     FunctionDeclaration,
     Identifier,
+    isTupleTypeNode,
+    isTypeLiteralNode,
+    isTypeReferenceNode,
     MethodDeclaration,
     MethodSignature,
     Node,
-    ObjectBindingPattern,
     ParameterDeclaration,
+    PropertySignature,
     SyntaxKind,
     VariableStatement,
 } from 'typescript';
@@ -15,9 +17,18 @@ import { ConstructorDeclaration as TshConstructor } from '../declarations/Constr
 import { DefaultDeclaration as TshDefault } from '../declarations/DefaultDeclaration';
 import { FunctionDeclaration as TshFunction } from '../declarations/FunctionDeclaration';
 import { MethodDeclaration as TshMethod } from '../declarations/MethodDeclaration';
-import { ParameterDeclaration as TshParameter } from '../declarations/ParameterDeclaration';
+import {
+    ArrayBoundParameterDeclaration,
+    ObjectBoundParameterDeclaration,
+    ParameterDeclaration as TshParameter,
+} from '../declarations/ParameterDeclaration';
 import { Resource } from '../resources/Resource';
-import { isArrayBindingPattern, isIdentifier, isObjectBindingPattern } from '../type-guards/TypescriptGuards';
+import {
+    isArrayBindingPattern,
+    isIdentifier,
+    isObjectBindingPattern,
+    isPropertySignature,
+} from '../type-guards/TypescriptGuards';
 import { parseIdentifier } from './identifier-parser';
 import { getDefaultResourceIdentifier, getNodeType, isNodeDefaultExported, isNodeExported } from './parse-utilities';
 import { parseVariable } from './variable-parser';
@@ -63,22 +74,51 @@ export function parseMethodParams(
 ): TshParameter[] {
     return node.parameters.reduce(
         (all: TshParameter[], cur: ParameterDeclaration) => {
-            let params = all;
+            const params = all;
             if (isIdentifier(cur.name)) {
                 params.push(new TshParameter(
                     (cur.name as Identifier).text, getNodeType(cur.type), cur.getStart(), cur.getEnd(),
                 ));
-            } else if (isObjectBindingPattern(cur.name) || isArrayBindingPattern(cur.name)) {
-                const identifiers = cur.name as ObjectBindingPattern | ArrayBindingPattern;
-                const elements = [...identifiers.elements];
-                // TODO: BindingElement
-                params = params.concat(<TshParameter[]>elements.map((o: any) => {
-                    if (isIdentifier(o.name)) {
-                        return new TshParameter(
-                            (o.name as Identifier).text, undefined, o.getStart(), o.getEnd(),
-                        );
-                    }
-                }).filter(Boolean));
+            } else if (isObjectBindingPattern(cur.name)) {
+                const elements = cur.name.elements;
+                let types: (string | undefined)[] = [];
+                const boundParam = new ObjectBoundParameterDeclaration(cur.getStart(), cur.getEnd());
+
+                if (cur.type && isTypeReferenceNode(cur.type)) {
+                    boundParam.typeReference = getNodeType(cur.type);
+                } else if (cur.type && isTypeLiteralNode(cur.type)) {
+                    types = cur.type.members
+                        .filter(member => isPropertySignature(member))
+                        .map((signature: any) => getNodeType((signature as PropertySignature).type));
+                }
+
+                boundParam.parameters = elements.map((bindingElement, index) => new TshParameter(
+                    bindingElement.name.getText(),
+                    types[index],
+                    bindingElement.getStart(),
+                    bindingElement.getEnd(),
+                ));
+
+                params.push(boundParam);
+            } else if (isArrayBindingPattern(cur.name)) {
+                const elements = cur.name.elements;
+                let types: (string | undefined)[] = [];
+                const boundParam = new ArrayBoundParameterDeclaration(cur.getStart(), cur.getEnd());
+
+                if (cur.type && isTypeReferenceNode(cur.type)) {
+                    boundParam.typeReference = getNodeType(cur.type);
+                } else if (cur.type && isTupleTypeNode(cur.type)) {
+                    types = cur.type.elementTypes.map(type => getNodeType(type));
+                }
+
+                boundParam.parameters = elements.map((bindingElement, index) => new TshParameter(
+                    bindingElement.getText(),
+                    types[index],
+                    bindingElement.getStart(),
+                    bindingElement.getEnd(),
+                ));
+
+                params.push(boundParam);
             }
             return params;
         },

test/TypescriptParser.spec.ts

@@ -253,6 +253,91 @@ describe('TypescriptParser', () => {
 
         });
 
+        describe('Parameters', () => {
+
+            const file = getWorkspaceFile('typescript-parser/parameters.ts');
+            let parsed: Resource;
+
+            beforeEach(async () => {
+                parsed = await parser.parseFile(file, rootPath);
+            });
+
+            it('should parse a normal parameter', () => {
+                const func = parsed.declarations[0] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse a simple array binding pattern', () => {
+                const func = parsed.declarations[1] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse an array with tuple type', () => {
+                const func = parsed.declarations[2] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse an array with undertyped tuple type', () => {
+                const func = parsed.declarations[3] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse an array with overtyped tuple type', () => {
+                const func = parsed.declarations[4] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse a simple object binding pattern ', () => {
+                const func = parsed.declarations[5] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse an object with type reference', () => {
+                const func = parsed.declarations[6] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse an object with type literal', () => {
+                const func = parsed.declarations[7] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse an object with undertyped type literal', () => {
+                const func = parsed.declarations[8] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse an object with overtyped type literal', () => {
+                const func = parsed.declarations[9] as FunctionDeclaration;
+                expect(func.parameters[0]).toMatchSnapshot();
+            });
+
+            it('should parse some mixed parameters (all above)', () => {
+                expect(parsed.declarations[10]).toMatchSnapshot();
+            });
+
+            it('should generate the correct name for an object', () => {
+                const func = parsed.declarations[9] as FunctionDeclaration;
+                expect(func.parameters[0].name).toMatchSnapshot();
+            });
+
+            it('should generate the correct name for an array', () => {
+                const func = parsed.declarations[2] as FunctionDeclaration;
+                expect(func.parameters[0].name).toMatchSnapshot();
+            });
+
+            it('should generate the correct type for an object', () => {
+                const func = parsed.declarations[9] as FunctionDeclaration;
+                expect(func.parameters[0].type).toMatchSnapshot();
+            });
+
+            it('should generate the correct type for an array', () => {
+                const func = parsed.declarations[2] as FunctionDeclaration;
+                expect(func.parameters[0].type).toMatchSnapshot();
+            });
+
+        });
+
         describe('Variables', () => {
 
             const file = getWorkspaceFile('typescript-parser/variable.ts');