Merge pull request #13 from ktutnik/master

add es6 default parameter transformer
ktutnik · Apr 21, 2017 · deb2d65 · deb2d65
2 parents 49188f7 + 77134a9
commit deb2d65
Show file tree

Hide file tree

Showing 8 changed files with 107 additions and 7 deletions.
diff --git a/src/analyzers/astree/parameter-analyzer.ts b/src/analyzers/astree/parameter-analyzer.ts
@@ -4,8 +4,14 @@ import { SyntaxKind, SourceLocation } from "../../core"
 export class ParameterAnalyzer {
     constructor(private node) { }
 
+    withDefaultValue(){
+        return this.node.type == SyntaxKind.AssignmentPattern
+    }
+
     getName() {
-        return this.node.name;
+        if(this.withDefaultValue())
+            return this.node.left.name
+        else return this.node.name;
     }
 
     getLocation() {

diff --git a/src/analyzers/baseclasses.ts b/src/analyzers/baseclasses.ts
@@ -77,6 +77,7 @@ export interface ModuleAnalyzer {
 export interface ParameterAnalyzer {
     getName(): string
     getLocation(): SourceLocation
+    withDefaultValue():boolean
 }
 
 export interface ValueAnalyzer{

diff --git a/src/core.ts b/src/core.ts
@@ -121,6 +121,7 @@ export namespace SyntaxKind {
     export const NullLiteral = "NullLiteral"
     export const ObjectExpression = "ObjectExpression"
     export const ObjectProperty = "ObjectProperty"
+    export const AssignmentPattern = "AssignmentPattern"
 }
 
 export module Call {

diff --git a/src/transformers/es6-class-member.ts b/src/transformers/es6-class-member.ts
@@ -1,14 +1,15 @@
 
 import * as Analyzer from "../analyzers"
 import { ParameterTransformer } from "./parameter"
+import { ParameterWithDefaultTransformer } from "./parameter-with-default"
 import * as Core from "../core"
 
 
 export class Es6ClassMember extends Core.TransformerBase {
     constructor(private parserType: Analyzer.ParserType) {
         super()
     }
-    
+
     @Core.Call.when(Core.SyntaxKind.ClassMethod)
     transform(node, parent: Core.ClassMetaData) {
         let analyser = <Analyzer.Es6MemberAnalyzer>Analyzer
@@ -23,13 +24,14 @@ export class Es6ClassMember extends Core.TransformerBase {
                 parameters: [],
                 decorators: undefined
             }
-            if(!parent.methods) parent.methods = []
-            if(type == "Method")
+            if (!parent.methods) parent.methods = []
+            if (type == "Method")
                 parent.methods.push(method)
-            if(type == "Constructor")
+            if (type == "Constructor")
                 parent.constructor = method
             this.traverse(analyser.getParameters(), method, [
-                new ParameterTransformer(this.parserType)
+                new ParameterTransformer(this.parserType),
+                new ParameterWithDefaultTransformer(this.parserType)
             ])
         }
     }

diff --git a/src/transformers/parameter-with-default.ts b/src/transformers/parameter-with-default.ts
@@ -0,0 +1,21 @@
+import * as Core from "../core"
+import * as Analyzer from "../analyzers"
+
+export class ParameterWithDefaultTransformer extends Core.TransformerBase {
+    constructor(private parserType: Analyzer.ParserType) {
+        super()
+    }
+
+    @Core.Call.when(Core.SyntaxKind.AssignmentPattern)
+    transform(node, parent: Core.MethodMetaData | Core.ConstructorMetaData) {
+        let analyzer = <Analyzer.ParameterAnalyzer>Analyzer
+            .get(this.parserType, Analyzer.AnalyzerType.Parameter, node)
+        if(!analyzer.withDefaultValue()) return
+        parent.parameters.push(<Core.ParameterMetaData>{
+            type: "Parameter",
+            name: analyzer.getName(),
+            analysis: Core.AnalysisType.Valid,
+            location: analyzer.getLocation(),
+        })
+    }
+}
diff --git a/src/transformers/parameter.ts b/src/transformers/parameter.ts
@@ -10,6 +10,7 @@ export class ParameterTransformer extends Core.TransformerBase {
     transform(node, parent: Core.MethodMetaData | Core.ConstructorMetaData) {
         let analyzer = <Analyzer.ParameterAnalyzer>Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Parameter, node)
+        if(analyzer.withDefaultValue()) return
         parent.parameters.push(<Core.ParameterMetaData>{
             type: "Parameter",
             name: analyzer.getName(),

diff --git a/test/dummy.es6.ts b/test/dummy.es6.ts
@@ -11,6 +11,6 @@ namespace Module {
 }
 
 export class MyClass extends Module.MyClass {
-    constructor(par1) { super() }
+    constructor(par1 = 50) { super() }
     myMethod() { }
 }
diff --git a/test/transformer.spec.ts b/test/transformer.spec.ts
@@ -185,5 +185,73 @@ describe("Transformer", () => {
                 location: { start: 0, end: 512 }
             })
         })
+
+        it("Should transform ES6 class with default parameter", () => {
+            let ast = JsParser.getAst(`
+                class MyClass {
+                    constructor(par1, par2 = 300){}
+                    myMethod(par1, par2 = 50) { }
+                }
+                exports.MyClass = MyClass;
+            `, true)
+            let test = new Transformer("file.js", "ASTree")
+            let result = test.transform(ast)
+            Chai.expect(result).deep.eq({
+                type: 'File',
+                name: 'file.js',
+                analysis: 1,
+                children:
+                [{
+                    type: 'Class',
+                    name: 'MyClass',
+                    baseClass: undefined,
+                    location: { start: 17, end: 152 },
+                    analysis: 31,
+                    methods:
+                    [{
+                        type: 'Method',
+                        name: 'myMethod',
+                        analysis: 1,
+                        location: { start: 105, end: 134 },
+                        parameters:
+                        [{
+                            type: 'Parameter',
+                            name: 'par1',
+                            analysis: 1,
+                            location: { start: 114, end: 118 }
+                        },
+                        {
+                            type: 'Parameter',
+                            name: 'par2',
+                            analysis: 1,
+                            location: { start: 120, end: 129 }
+                        }],
+                        decorators: undefined
+                    }],
+                    constructor:
+                    {
+                        type: 'Constructor',
+                        name: 'constructor',
+                        analysis: 1,
+                        location: { start: 53, end: 84 },
+                        parameters:
+                        [{
+                            type: 'Parameter',
+                            name: 'par1',
+                            analysis: 1,
+                            location: { start: 65, end: 69 }
+                        },
+                        {
+                            type: 'Parameter',
+                            name: 'par2',
+                            analysis: 1,
+                            location: { start: 71, end: 81 }
+                        }],
+                        decorators: undefined
+                    }
+                }],
+                location: { start: 0, end: 208 }
+            })
+        })
     })
 })