public void TestEmptyclassWithBaseClassAndGenericArgumentsAndBaseClassWithParameter() { var expectedResult = @"class TestClass<Type1, Type2> extends TestClassBase<Type1> { } "; var tsClass = new TypescriptClass { Name = "TestClass", BaseClass = new TypescriptBaseClass { Name = "TestClassBase", }.ToOption() }; tsClass.GenricTypeParameters.Add(new TypescriptGenericTypeParameter { Name = "Type1" }); tsClass.GenricTypeParameters.Add(new TypescriptGenericTypeParameter { Name = "Type2" }); tsClass.BaseClass.IfNotNullDo(baseClass => baseClass.GenericArguments.Add(tsClass.GenricTypeParameters[0])); AssertThatWritingClassGivesTheExpectedResult(expectedResult, tsClass); }
private void WriteClassStart(TypescriptClass tsClass) { syntaxWriter.Write(TypescriptSyntaxKeywords.@class + " " + tsClass.Name); WriteGenericParameters(tsClass.GenricTypeParameters); WriteBaseClass(tsClass.BaseClass); WriteInterfaceImplementations(tsClass.InterfaceImplementations); syntaxWriter.WriteSpace(); WriteOpeningBracket(); }
/// <summary> /// Writes a typescript class and its contents. /// </summary> /// <param name="tsClass">the Class to write.</param> public void WriteClass(TypescriptClass tsClass) { WriteClassStart(tsClass); tsClass.Content.Match( WriteTypescriptFunctionWithAccesabilty, WriteProperty, WriteCode); WriteClosingBracket(); }
public TypescriptType GetTypeFor(Type type, TypescriptModel model) { if (model.knownTypes.ContainsKey(type)) { return(model.knownTypes[type]); } else { var newClass = new TypescriptClass { Name = NameWithoutGeneric(type) }; model.knownTypes.Add(type, newClass.ToTypescriptType()); newClass.BaseClass = GetBaseClassFor(type.BaseType, model); newClass.Content = new TypescriptClassContentList(GetClassContent(type, model)); newClass.GenricTypeParameters = TypescriptTypeCreatorBase.GetGenericTypeParametersFor(type); return(newClass.ToTypescriptType()); } }
public static TypescriptType ClassTypeToTypescriptClass(this Type type, ITypescriptTypeCreator typeCreator, TypescriptModel model) { // TODO Check if type is indeed a class.. if (model.knownTypes.ContainsKey(type)) { return(model.knownTypes[type]); } else { var newClass = new TypescriptClass { Name = type.NameWithoutGeneric() }; model.knownTypes.Add(type, newClass.ToTypescriptType()); newClass.BaseClass = type.BaseType.ToTypescriptBaseClass(model); newClass.Content = type.GetTypescriptProperties(typeCreator, model).ToClassContent(); newClass.GenricTypeParameters = TypescriptTypeCreatorBase.GetGenericTypeParametersFor(type); return(newClass.ToTypescriptType()); } }
public void TestEmptyclassWithBaseClassAndGenericArgument() { var expectedResult = @"class TestClass<Type1> extends TestClassBase { } "; var tsClass = new TypescriptClass { Name = "TestClass", GenricTypeParameters = new TypescriptGenericTypeParameters { new TypescriptGenericTypeParameter { Name = "Type1" } }, BaseClass = new TypescriptBaseClass { Name = "TestClassBase" }.ToOption() }; AssertThatWritingClassGivesTheExpectedResult(expectedResult, tsClass); }
public void WriteEnumProperty() { var expectedResult = @"class Test { public PropertyName: EnumName; } "; var enumerable = new TypescriptClass { Name = "Test", Content = new TypescriptClassContentList { new TypescriptProperty { Name = "PropertyName", Type = new TypescriptEnumerable { Name = "EnumName" }.ToTypescriptType() } } }; AssertThatWritingEnumGivesTheExpectedResult(expectedResult, enumerable); }
private static void AssertThatWritingClassGivesTheExpectedResult(string expectedresult, TypescriptClass tsClass) { var writer = new TypescriptWriter(); writer.WriteClass(tsClass); var result = writer.ToString(); result.ShouldBeEquivalentTo(expectedresult); }