/// <summary> /// Writes a typescript module and its contents. /// </summary> /// <param name="tsModule"></param> public void WriteModule(TypescriptModule tsModule) { syntaxWriter.Write(TypescriptSyntaxKeywords.module + " " + tsModule.Name); syntaxWriter.WriteSpace(); WriteOpeningBracket(); tsModule.Content.AllButLast().Match( module => { WriteModule(module); syntaxWriter.WriteLine(); }, tsClass => { WriteClass(tsClass); syntaxWriter.WriteLine(); }, tsInterface => { WriteInterface(tsInterface); syntaxWriter.WriteLine(); }, tsFunction => { WriteFunctionStandAlone(tsFunction); syntaxWriter.WriteLine(); }, tsEnum => { WriteEnum(tsEnum); syntaxWriter.WriteLine(); }, tsCode => { WriteCode(tsCode); syntaxWriter.WriteLine(); }); if (tsModule.Content.Any()) { tsModule.Content.Last().Match( WriteModule, WriteClass, WriteInterface, WriteFunctionStandAlone, WriteEnum, WriteCode); } WriteClosingBracket(); }
public void WriteComplexModule() { var expectedResult = @"module TestModule { class TestClass<Type1, Type2> extends TestClassBase<Type1, Type2> { } interface TestInterface<Type1, Type2> { } class TestClass { } function TestFunction(): void{ return 0; } } "; var module = new TypescriptModule { Name = "TestModule", }; module.Content.Add(TestData.classWithGenericBaseAndGenerics); module.Content.Add(TestData.interfaceWithGenerics); module.Content.Add(TestData.simpleClass); module.Content.Add(TestData.simpleFunction); AssertThatWritingModuleGivesTheExpectedResult(expectedResult, module); }
public static TypescriptModule RemoveEmptyDeclarations(TypescriptModule module, params DeclarationBase[] exceptions) { var o = new Optimizer(); o.Exceptions.AddRange(exceptions); return(o.RewriteModule(module)); }
private static Tuple <string, string> runTest(bool sourceClasses, bool destClasses, bool optimize, bool optimizeSource = false) { var rg = new ReflectionGenerator(); rg.GenerationStrategy.GenerateClasses = sourceClasses; rg.NamingStrategy.InterfacePrefixForClasses = ""; rg.NamingStrategy.InterfacePrefix = ""; rg.GenerateTypes(new[] { typeof(Test3), typeof(Test3A) }); var models = rg.Module; if (optimizeSource) { models = Optimizer.RemoveEmptyDeclarations(models); } var o1 = new OutputGenerator(); o1.Generate(models); var o1Output = o1.Output; var ko = new KnockoutGenerator(); var observables = new TypescriptModule("Observables"); ko.GenerateObservableModule(models, observables, !destClasses); if (optimize) { observables = Optimizer.RemoveEmptyDeclarations(observables); } var o2 = new OutputGenerator(); o2.Generate(observables); return(Tuple.Create(o1.Output, o2.Output)); }
public void TestModule() { var m = new TypescriptModule("testModule"); var cls = new ClassType("class1"); cls.Members.Add(new PropertyMember("Property1") { MemberType = PrimitiveType.Boolean }); m.Members.Add(cls); m.Members.Last().IsExporting = true; m.Members.Add(new RawStatements() { Statements = { "function test() : ", cls, " { return null; }" } }); var g = new OutputGenerator(); g.Generate(m); Assert.AreEqual(@" module testModule { export class class1 { Property1: boolean; } function test() : class1 { return null; } } ".Trim(), g.Output.Trim()); }
public virtual void VisitModule(TypescriptModule module) { foreach (var moduleMember in module.Members.ToArray()) { Visit(moduleMember); } }
public void TestComments() { var m = new TypescriptModule("testModule") { Comment = "module" }; var cls = new ClassType("class1"); cls.Members.Add(new PropertyMember("Property1") { MemberType = PrimitiveType.Boolean, Comment = "property\nsecond line" }); m.Members.Add(cls); m.Members.Last().Comment = "class"; m.Members.Last().IsExporting = true; m.Members.Add(new RawStatements() { Statements = { "function test() : ", cls, " { return null; }" } }); m.Members.Last().Comment = "raw"; cls.Members.Add(new FunctionMember("fn", new RawStatements("/*comment*/\n", "dosomething();\n", "//comment")) { Comment = "function", Parameters = { new FunctionParameter("x") { ParameterType = PrimitiveType.Boolean, Comment = "param" } } }); cls.Members.Last().Comment = "function"; var g = new OutputGenerator(); g.GenerateComments = true; g.Generate(m); Assert.AreEqual(null, Helper.StringCompare(@" /* module */ module testModule { /* class */ export class class1 { /* property * second line */ Property1: boolean; /* function */ fn(/* param */x: boolean) { /*comment*/ dosomething(); //comment } } /* raw */ function test() : class1 { return null; } } ", g.Output)); }
public void TestInterfacesToObservableClasses() { var rg = new ReflectionGenerator(); rg.GenerationStrategy.GenerateClasses = false; rg.GenerateTypes(new[] { typeof(Test1B), typeof(Test1) }); var o1 = new OutputGenerator(); o1.Generate(rg.Module); Assert.AreEqual(Helper.StringCompare(@" module GeneratedModule { interface ITest1 { Prop1: string; Prop2: number; } interface ITest1B extends ITest1 { Prop3: boolean; Ref: ITest1; PropArray: string[]; SelfArray: ITest1B[]; } } ", o1.Output), null); var ko = new KnockoutGenerator(); var observables = new TypescriptModule("Observables"); ko.GenerateObservableModule(rg.Module, observables, interfaces: false); var o = new OutputGenerator(); o.Generate(observables); Assert.AreEqual(null, Helper.StringCompare(@" module Observables { class test1B implements IObservableTest1 { // implementation of IObservableTest1 Prop1 = ko.observable<string>(); Prop2 = ko.observable<number>(); Prop3 = ko.observable<boolean>(); Ref = ko.observable<test1>(); PropArray = ko.observableArray<string>(); SelfArray = ko.observableArray<test1B>(); } interface IObservableTest1 { Prop1: KnockoutObservable<string>; Prop2: KnockoutObservable<number>; } class test1 { Prop1 = ko.observable<string>(); Prop2 = ko.observable<number>(); } } ", o.Output)); }
public virtual TypescriptModule RewriteModule(TypescriptModule module) { var result = new TypescriptModule(module.Name) { Comment = RewriteComment(module.Comment), ExtraData = RewriteExtraData(module) }; result.Members.AddRange(module.Members.Select(RewriteModuleElement).Where(x => x != null)); return(result); }
public static IEnumerable <Type> ExtractGeneratedTypes(TypescriptModule module) { return(module.Members .OfType <DeclarationModuleElement>() .SelectMany(d => new TypeDomBase[] { d.Declaration, d.EnumDeclaration }) .Where(d => d != null) .Select(d => GetGeneratedType(d)) .Where(t => t != null) .Concat( module.Members.OfType <DeclarationModuleElement>().Where(dm => dm.InnerModule != null).SelectMany(dm => ExtractGeneratedTypes(dm.InnerModule)) ) .ToArray()); }
public void WriteEmptyModule() { var expectedResult = @"module TestModule { } "; var module = new TypescriptModule { Name = "TestModule", }; AssertThatWritingModuleGivesTheExpectedResult(expectedResult, module); }
public static void MakeObservable(TypescriptModule module) { foreach (var item in module.Members.OfType <DeclarationModuleElement>()) { if (item.Declaration is InterfaceType) { MakeObservable((InterfaceType)item.Declaration); } else if (item.Declaration is ClassType) { MakeObservable((ClassType)item.Declaration); } } }
public void WriteModuleWithClass() { var expectedResult = @"module TestModule { class TestClass { } } "; var module = new TypescriptModule { Name = "TestModule", }; module.Content.Add(TestData.simpleClass); AssertThatWritingModuleGivesTheExpectedResult(expectedResult, module); }
public void TestClassesToObservableInterfaces() { var rg = new ReflectionGenerator(); rg.GenerationStrategy.GenerateClasses = true; rg.GenerateTypes(new[] { typeof(Test1B), typeof(Test1) }); var o1 = new OutputGenerator(); o1.Generate(rg.Module); Assert.AreEqual(@" module GeneratedModule { class Test1 { Prop1: string; Prop2: number; } class Test1B extends Test1 { Prop3: boolean; Ref: Test1; PropArray: string[]; SelfArray: Test1B[]; } } ".Trim(), o1.Output.Trim()); var ko = new KnockoutGenerator(); var observables = new TypescriptModule("Observables"); ko.GenerateObservableModule(rg.Module, observables, true); var o = new OutputGenerator(); o.Generate(observables); Assert.AreEqual(@" module Observables { interface iObservableTest1 { Prop1: KnockoutObservable<string>; Prop2: KnockoutObservable<number>; } interface iObservableTest1B extends iObservableTest1 { Prop3: KnockoutObservable<boolean>; Ref: KnockoutObservable<iObservableTest1>; PropArray: KnockoutObservableArray<string>; SelfArray: KnockoutObservableArray<iObservableTest1B>; } } ".Trim(), o.Output.Trim()); }
public override TypescriptModule RewriteModule(TypescriptModule module) { var r = base.RewriteModule(module); var changed = true; while (changed) { changed = false; foreach (var m in r.Members.Where(IsEmptyDeclaration).ToArray()) { changed = true; r.Members.Remove(m); } } ; return(r); }
public void WriteModuleWithCode() { var expectedResult = @"module TestModule { var a = 1; var b = 2; } "; var module = new TypescriptModule { Name = "TestModule", }; module.Content.Add(new TypescriptCode { "var a = 1;", "var b = 2;" }); AssertThatWritingModuleGivesTheExpectedResult(expectedResult, module); }
public void WriteModuleWithModule() { var expectedResult = @"module TestModule { module TestModule2 { } } "; var module = new TypescriptModule { Name = "TestModule", }; module.Content.Add(new TypescriptModule { Name = "TestModule2", }); AssertThatWritingModuleGivesTheExpectedResult(expectedResult, module); }
public void GenerateObservableModule(TypescriptModule source, TypescriptModule target, bool interfaces) { // src class -> class base class -> class implemented interfaces -> implements obsInterface // src interface -> !implementation class implemented interfaces -> implements observableInterface + code implementation (makes sense, interface defines api for server, I want to create model ) // src class -> interface base class -> obsInterface implemented interfaces -> implements obsInterface (makes sense, I want to implement model myself, interfaces defines content) // src interface -> interface base class -> obsInterface implemented interfaces -> implements obsInterface _target = target; BeginInterfaceMapping(interfaces); try { foreach (var item in source.Members.OfType <DeclarationModuleElement>().Where(d => d.Declaration != null)) { MapDeclaration(item.Declaration, createMap: true); } } finally { EndInterfaceMapping(); } }
public virtual void Visit(TypescriptModule module) { VisitModule(module); }
private static void AssertThatWritingModuleGivesTheExpectedResult(string expectedresult, TypescriptModule tsModule) { var writer = new TypescriptWriter(); writer.WriteModule(tsModule); var result = writer.ToString(); result.ShouldBeEquivalentTo(expectedresult); }
public KoGenerationStrategy() { TargetModule = new TypescriptModule("Observables"); }
public GenerationStrategy() { TargetModule = new TypescriptModule("GeneratedModule"); }
public void GenerateControllers(IEnumerable <ControllerModel> controllers, ReflectionGeneratorBase reflectionGenerator, TypescriptModule targetModule) { var proxyClass = new ClassType("GeneratedProxy"); if (!String.IsNullOrEmpty(ProxyBaseName)) { proxyClass.Extends = new TypescriptTypeReference(ProxyBaseName); } targetModule.Members.Add(new DeclarationModuleElement(proxyClass) { IsExporting = true }); foreach (var controller in controllers) { var cls = new ClassType(controller.Name + "Proxy"); var proxyType = new TypescriptTypeReference(GeneratedClassName); cls.Members.Add(new PropertyMember("_parent") { MemberType = proxyType, Accessibility = AccessibilityEnum.Private }); //cls.Members.Add(new RawStatements("constructor(parent: ", proxyType, ") {\n\tthis._parent = parent;\n}")); cls.Members.Add(new FunctionMember("constructor", new RawStatements("this._parent = parent;")) { Accessibility = null, Parameters = { new FunctionParameter("parent") { ParameterType = proxyType } }, }); foreach (var am in controller.Actions) { cls.Members.Add(GenerateAction(am, reflectionGenerator)); } targetModule.Members.Add(cls); targetModule.Members.Last().Comment = controller.Comment; proxyClass.Members.Add(new PropertyMember(controller.Name.Replace("Controller", "")) { MemberType = cls, Accessibility = AccessibilityEnum.Public, Initialization = new RawStatements("new ", cls, "(this)") }); } targetModule.Members.Add(new RawStatements("export var proxy = new ", proxyClass, "();")); }