Adding decorator parameter

src/analyzers/astree/child-decorator-analyzer.ts

@@ -26,7 +26,7 @@ export class ChildDecoratorAnalyzer implements Base.ChildDecoratorAnalyzer {
     }
 
     getMethodParameters() {
-        return this.node.arguments.map(x => this.getParameter(x));
+        return this.node.arguments.map(x => H.getDecoratorParameterName(x));
     }
 
     getParameterDecoratorName() {
@@ -42,19 +42,7 @@ export class ChildDecoratorAnalyzer implements Base.ChildDecoratorAnalyzer {
 
     getParameterDecoratorParameters() {
         return this.node.arguments[1].arguments
-            .map(x => this.getParameter(x));
+            .map(x => H.getDecoratorParameterName(x));
     }
 
-
-    private getParameter(x) {
-        return <MetaData>{
-            type: "Parameter",
-            name: H.getDecoratorParameterName(x),
-            analysis: AnalysisType.Valid,
-            location: <SourceLocation>{
-                start: this.node.start,
-                end: this.node.end
-            },
-        };
-    }
 }

src/analyzers/astree/helper.ts

@@ -1,4 +1,5 @@
-import { SyntaxKind, MetaData, AnalysisType } from "../../core"
+import { SyntaxKind, MetaData, AnalysisType, ValueMetaData, ValueMetaDataType, PrimitiveValueMetaData, ObjectValueMetaData, ArrayValueMetaData } from "../../core"
+import * as Analyzer from "../../analyzers"
 
 /**
  * require CallExpression.callee
@@ -18,15 +19,62 @@ export function isReservedDecorator(callExpression) {
         || getMethodNameFromCallee(callExpression.callee) == "__decorate"
 }
 
-export function getDecoratorParameterName(param) {
+export function getDecoratorParameterName(param):ValueMetaData {
     switch (param.type) {
         case SyntaxKind.StringLiteral:
+            return getPrimitiveParameter("String", param)
         case SyntaxKind.NumericLiteral:
+            return getPrimitiveParameter("Number", param)
         case SyntaxKind.BooleanLiteral:
-            return param.value;
-        case SyntaxKind.Identifier:
-            return param.name;
+            return getPrimitiveParameter("Boolean", param)
+        case SyntaxKind.NullLiteral:
+            return getPrimitiveParameter("Null", param)
+        case SyntaxKind.ArrayExpression:
+            return getArrayParameter(param)
+        case SyntaxKind.ObjectExpression:
+            return getObjectParameter(param)
         default:
-            return "Unknown";
+            return <ValueMetaData>{
+                type: "Unknown"
+            };
     }
-}
+}
+
+function getPrimitiveParameter(type: ValueMetaDataType, param) {
+    return <PrimitiveValueMetaData>{
+        type: type,
+        value: param.value
+    }
+}
+
+
+function getArrayParameter(param) {
+    let result = <ArrayValueMetaData>{
+        type: "Array",
+        children: []
+    }
+    for (let item of param.elements) {
+        result.children.push(getDecoratorParameterName(item))
+    }
+    return result;
+}
+
+function getPropertyParameter(param) {
+    let value = getDecoratorParameterName(param.value);
+    return <PrimitiveValueMetaData>{
+        type: value.type,
+        name: param.key.name,
+        value: value
+    }
+}
+
+function getObjectParameter(param) {
+    let result = <ObjectValueMetaData>{
+        type: "Object",
+        properties: []
+    }
+    for (let item of param.properties) {
+        result.properties.push(getPropertyParameter(item))
+    }
+    return result
+}

src/analyzers/baseclasses.ts

@@ -1,19 +1,19 @@
-import { SyntaxKind, MethodMetaData, MetaData, AnalysisType, SourceLocation } from "../core"
+import { SyntaxKind, MethodMetaData, MetaData, ValueMetaData, AnalysisType, SourceLocation } from "../core"
 
 export type ParserType = "ASTree" | "Acorn"
 export enum AnalyzerType {
-    File, Decorator, ChildDecorator, TSClass, TSModule, Constructor, Method, Parameter
+    File, Decorator, ChildDecorator, TSClass, TSModule, Constructor, Method, Parameter, ValueAnalyzer
 }
 
 export interface ChildDecoratorAnalyzer {
     isMethodDecorator(): boolean
     isParameterDecorator(): boolean
     getMethodName(): string
     getMethodLocation(): SourceLocation
-    getMethodParameters(): MetaData[]
+    getMethodParameters(): ValueMetaData[]
     getParameterDecoratorName(): string
     getParameterDecoratorLocation(): SourceLocation
-    getParameterDecoratorParameters(): MetaData[]
+    getParameterDecoratorParameters(): ValueMetaData[]
 }
 
 export interface ClassAnalyzer {
@@ -67,4 +67,14 @@ export interface ModuleAnalyzer {
 export interface ParameterAnalyzer {
     getName(): string
     getLocation(): SourceLocation
+}
+
+export interface ValueAnalyzer{
+    isPrimitive()
+    isObject()
+    isArray()
+    isNull()
+    isProperty()
+    getValue()
+    getName()
 }

src/analyzers/index.ts

@@ -21,5 +21,6 @@ export {
     FileAnalyzer, 
     MethodAnalyzer, 
     ModuleAnalyzer, 
-    ParameterAnalyzer
+    ParameterAnalyzer,
+    ValueAnalyzer
 } from "./baseclasses"

src/core.ts

@@ -18,11 +18,35 @@ export type MetadataType = "File" | "Module" | "Class"
     | "Method" | "Parameter" | "Decorator"
     | "Function" | "Constructor" | "Property"
 
+export type ValueMetaDataType = "Object" | "String" | "Boolean"
+    | "Number" | "Array" | "Null" | "Unknown"
+
 export interface SourceLocation {
     start: number,
     end: number
 }
 
+export interface ValueMetaData {
+    type: ValueMetaDataType
+    name?: string
+    location?: SourceLocation
+}
+
+export interface PrimitiveValueMetaData  extends ValueMetaData{
+    type: "String" | "Boolean" | "Number" | "Null"
+    value: any
+}
+
+export interface ObjectValueMetaData extends ValueMetaData{
+    type: "Object",
+    properties: ValueMetaData[]
+}
+
+export interface ArrayValueMetaData extends ValueMetaData {
+    type: "Array",
+    children: ValueMetaData[]
+}
+
 export interface MetaData {
     type: MetadataType
     name: string
@@ -32,9 +56,10 @@ export interface MetaData {
 
 export interface DecoratorMetaData extends MetaData {
     type: "Decorator"
-    parameters: MetaData[]
+    parameters: ValueMetaData[]
 }
 
+
 export interface ParameterMetaData extends MetaData {
     type: "Parameter"
     decorators: DecoratorMetaData[]
@@ -94,6 +119,8 @@ export module SyntaxKind {
     export const ClassExpression = "ClassExpression"
     export const UnaryExpression = "UnaryExpression"
     export const NullLiteral = "NullLiteral"
+    export const ObjectExpression = "ObjectExpression"
+    export const ObjectProperty = "ObjectProperty"
 }
 
 export module Call {

src/transformers/ts-child-decorator.ts

@@ -20,6 +20,7 @@ export class TsChildDecoratorTransformer extends Core.TransformerBase {
             let parameter = parent.parameters[parseInt(node.arguments[0].value)]
             this.transformParameter(analyzers, parameter)
         }
+
     }
 
     private transformMethod(analyzer: Analyzer.ChildDecoratorAnalyzer, parent: Core.MethodMetaData | Core.ClassMetaData | Core.PropertyMetaData) {

src/transformers/value.ts

@@ -0,0 +1,80 @@
+import * as Analyzer from "../analyzers"
+import { ParameterTransformer } from "./parameter"
+import * as Core from "../core"
+
+
+export class BooleanValueTransformer extends Core.TransformerBase {
+    constructor(private parserType: Analyzer.ParserType) {
+        super()
+    }
+
+    @Core.Call.when(Core.SyntaxKind.BooleanLiteral)
+    transform(node, parent: Core.DecoratorMetaData) {
+        let analyser = <Analyzer.ValueAnalyzer>Analyzer
+            .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node)
+        if (analyser.isPrimitive()) {
+            if(!parent.parameters) parent.parameters = []
+            parent.parameters.push(<Core.PrimitiveValueMetaData>{
+                type: "Boolean",
+                value: analyser.getValue()
+            })
+        }
+    }
+}
+
+export class StringValueTransformer extends Core.TransformerBase {
+    constructor(private parserType: Analyzer.ParserType) {
+        super()
+    }
+
+    @Core.Call.when(Core.SyntaxKind.StringLiteral)
+    transform(node, parent: Core.DecoratorMetaData) {
+        let analyser = <Analyzer.ValueAnalyzer>Analyzer
+            .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node)
+        if (analyser.isPrimitive()) {
+            if(!parent.parameters) parent.parameters = []
+            parent.parameters.push(<Core.PrimitiveValueMetaData>{
+                type: "String",
+                value: analyser.getValue()
+            })
+        }
+    }
+}
+
+export class NumberValueTransformer extends Core.TransformerBase {
+    constructor(private parserType: Analyzer.ParserType) {
+        super()
+    }
+
+    @Core.Call.when(Core.SyntaxKind.NumericLiteral)
+    transform(node, parent: Core.DecoratorMetaData) {
+        let analyser = <Analyzer.ValueAnalyzer>Analyzer
+            .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node)
+        if (analyser.isPrimitive()) {
+            if(!parent.parameters) parent.parameters = []
+            parent.parameters.push(<Core.PrimitiveValueMetaData>{
+                type: "Number",
+                value: analyser.getValue()
+            })
+        }
+    }
+}
+
+export class NullValueTransformer extends Core.TransformerBase {
+    constructor(private parserType: Analyzer.ParserType) {
+        super()
+    }
+
+    @Core.Call.when(Core.SyntaxKind.NullLiteral)
+    transform(node, parent: Core.DecoratorMetaData) {
+        let analyser = <Analyzer.ValueAnalyzer>Analyzer
+            .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node)
+        if (analyser.isNull()) {
+            if(!parent.parameters) parent.parameters = []
+            parent.parameters.push(<Core.PrimitiveValueMetaData>{
+                type: "Null",
+                value: analyser.getValue()
+            })
+        }
+    }
+}