/// <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, "();"));
}
