public void ConvertSingleClassToInterface()
{
var propertyNames = new string[] { "MyPropertyString", "MyPropertyInt", "EnumProperty", "NullableDateTime", "GuidProperty" };
var model = new TypescriptModel();
var result = new TypescriptClassesAsInterfaceCreator().GetTypeFor(typeof(SomeClass), model);
result.Match(primitive => Assert.Fail(),
tsclass => Assert.Fail(),
tsInerface =>
{
Assert.AreEqual(tsInerface.Name, typeof(SomeClass).Name);
tsInerface.Content.Match(functionSignature => Assert.Fail(), property => Assert.IsTrue(propertyNames.Contains(property.Name)));
},
tsenum => Assert.Fail(),
tsTypeParam => Assert.Fail());
}
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());
}
}
protected virtual IEnumerable <TypescriptProperty> GetTypescriptProperties(Type type, TypescriptModel model)
{
return(type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public).Select(property => new TypescriptProperty
{
Name = property.Name,
Accesability = TypescriptAccesModifier.@public,
DefaultValue = new None <String>(),
Type = typeCreator.GetTypeFor(property.PropertyType, model)
}));
}
protected virtual IEnumerable <TypescriptClassContent> GetClassContent(Type type, TypescriptModel model)
{
return(GetTypescriptProperties(type, model).Select(property => property.ToTypescriptClassContent()));
}
protected virtual IOption <TypescriptBaseClass> GetBaseClassFor(Type baseType, TypescriptModel model)
{
if (baseType == typeof(Object))
{
return(new None <TypescriptBaseClass>());
}
return(new TypescriptBaseClass
{
Name = NameWithoutGeneric(baseType),
GenericArguments = TypescriptTypeCreatorBase.GetGenericTypeParametersAsArguments(baseType)
}.ToOption());
}
