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);
}
