/// <summary> /// Appends the appropriate class definition for the specified member /// </summary> /// <param name="classModel"></param> /// <param name="sb"></param> /// <param name="generatorOutput"></param> protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { Tags.TryGetValue(classModel, out string tag); sb.AppendLineIndented($"// {classModel.Name} ({tag})"); switch (tag) { case KoClass: AppendClassDefinition(classModel, sb, generatorOutput, true); break; case KoInterface: AppendKoInterfaceDefinition(classModel, sb, generatorOutput); break; case Poco: AppendClassDefinition(classModel, sb, generatorOutput, false); break; default: base.AppendClassDefinition(classModel, sb, generatorOutput); break; } _generatedClasses.Add(classModel); }
/// <summary> /// Generates class definition and appends it to the output. /// </summary> /// <param name="classModel">The class to generate definition for.</param> /// <param name="sb">The output.</param> /// <param name="generatorOutput"></param> protected virtual void AppendConstantModule(TsClass classModel, ScriptBuilder sb) { if (!classModel.Constants.Any()) { return; } string typeName = this.GetTypeName(classModel); sb.AppendLineIndented(string.Format("export namespace {0} {{", typeName)); using (sb.IncreaseIndentation()) { foreach (var property in classModel.Constants) { if (property.IsIgnored) { continue; } _docAppender.AppendConstantModuleDoc(sb, property, this.GetPropertyName(property), this.GetPropertyType(property)); sb.AppendFormatIndented("export const {0}: {1} = {2};", this.GetPropertyName(property), this.GetPropertyType(property), this.GetPropertyConstantValue(property)); sb.AppendLine(); } } sb.AppendLineIndented("}"); _generatedClasses.Add(classModel); }
public void WhenInitializedWithInnerClass_ModuleIsSetToNamespaceAndOuterClass() { var target = new TsClass(typeof(TypeLite.Tests.TestModels.Outer.Inner)); Assert.NotNull(target.Module); Assert.Equal(typeof(TypeLite.Tests.TestModels.Outer.Inner).Namespace + ".Outer", target.Module.Name); }
private static string TypeFormatter(TsType tsType, ITsTypeFormatter f) { TsClass tsClass = (TsClass)tsType; //Prefix classname with I return("I" + tsClass.Name); }
private void AddRequestRenameInformation(ScriptBuilder sb, TsClass classModel) { if (_restSpec.SkipRequestImplementation(classModel.Name)) { return; } var i = classModel.Name; if (!ClientTypesExporter.InterfaceRegex.IsMatch(i)) { i = $"I{i}"; } if (_restSpec.SkipRequestImplementation(i)) { return; } if (!_restSpec.Requests.TryGetValue(i, out var mapping)) { throw new Exception($"Could not get {i} original rest spec file name"); } var originalSpec = Path.GetFileNameWithoutExtension(mapping.Json.Name); sb.AppendLineIndented($"@rest_spec_name(\"{originalSpec}\")"); }
public void WhenInitialized_ModuleIsSetToNamespaceModule() { var target = new TsClass(typeof(Address)); Assert.NotNull(target.Module); Assert.Equal(typeof(Address).Namespace, target.Module.Name); }
public void WhenInitializedWithClassThatHasBaseClass_BaseTypeIsSet() { var target = new TsClass(typeof(Employee)); Assert.NotNull(target.BaseType); Assert.Equal(typeof(Person), target.BaseType.Type); }
public void WhenInitialized_PropertiesAreCreated() { var target = new TsClass(typeof(Address)); Assert.Single(target.Properties.Where(o => o.MemberInfo == typeof(Address).GetProperty("Street"))); Assert.Single(target.Properties.Where(o => o.MemberInfo == typeof(Address).GetProperty("Town"))); }
private void GenerateProperties(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { var members = new List <TsProperty>(); if ((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) { members.AddRange(classModel.Properties); } if ((generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields) { members.AddRange(classModel.Fields); } using (sb.IncreaseIndentation()) { foreach (var property in members) { if (property.IsIgnored || PropertyTypesToIgnore(property.PropertyType.Type) || (_typesPropertiesToIgnore.ContainsKey(classModel.Type) && _typesPropertiesToIgnore[classModel.Type].Contains(property.Name))) { continue; } AddDocCommentForCustomJsonConverter(sb, property); _docAppender.AppendPropertyDoc(sb, property, this.GetPropertyName(property), this.GetPropertyType(property)); sb.AppendLineIndented($"{this.GetPropertyName(property)}: {this.GetPropertyType(property)};"); } if (classModel.Type == typeof(PropertyBase)) { sb.AppendLineIndented($"type: string;"); } } }
protected virtual List <TsClass> SortByDependency(List <TsClass> tsClasses) { List <TsClass> sorted = new List <TsClass>(); Queue <TsClass> queue = new Queue <TsClass>(tsClasses); while (queue.Count > 0) { TsClass processedClass = queue.Dequeue(); if (processedClass.BaseType == null) { if (!sorted.Contains(processedClass)) { sorted.Add(processedClass); } } else { TsClass baseClass = tsClasses.Single(c => c.Type.FullName == processedClass.BaseType.Type.FullName); if (sorted.Contains(baseClass)) { if (!sorted.Contains(processedClass)) { sorted.Add(processedClass); } } else { queue.Enqueue(processedClass); } } } return(sorted); }
public virtual string WriteClass(TsClass netClass) { var exportStr = netClass.IsPublic ? "export " : ""; var extends = netClass.BaseTypes.Any() ? " extends " + string.Join(", ", netClass.BaseTypes.Select(WriteTypeName)) : ""; var generics = netClass.GenericParameters.Any() ? $" <{string.Join(", ", netClass.GenericParameters.Select(WriteGenericParameter))}>" : ""; var methods = GetMethodsString(netClass); var fields = GetFieldsString(netClass); //var properties = GetPropertiesString(netClass); var events = GetEventsString(netClass); var nestedClasses = GetNestedClassesString(netClass); var body = JoinBodyText(fields, events, methods); //TODO: config for brackets on same line as declaration return($"{exportStr}class {netClass.Name}{generics}{extends}" + _config.NewLine + @"{" + _config.NewLine + body + @"}" + nestedClasses); }
/// <summary> /// Generates class definition and appends it to the output. /// </summary> /// <param name="classModel">The class to generate definition for.</param> /// <param name="sb">The output.</param> protected virtual void AppendConstantModule(TsClass classModel, IndentedStringBuilder sb) { if (!classModel.Constants.Any()) { return; } var typeName = GetTypeName(classModel); sb.AppendLine(string.Format("export module {0} {{", typeName)); using (sb.Indent()) { foreach (var property in classModel.Constants) { if (property.IsIgnored) { continue; } DocAppender.AppendConstantModuleDoc(sb, property, GetPropertyName(property), GetPropertyType(property)); sb.Append(string.Format("export var {0}: {1} = {2};", GetPropertyName(property), GetPropertyType(property), GetPropertyConstantValue(property))); sb.AppendLine(); } } sb.AppendLine("}"); GeneratedClasses.Add(classModel); }
private void AppendInterfaceDef(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { AddNamespaceHeaderEnum(classModel.Name, classModel.Type.Assembly.FullName, sb); var typeName = this.GetTypeName(classModel); var visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; _docAppender.AppendClassDoc(sb, classModel, typeName); sb.AppendFormatIndented("{0}interface {1}", visibility, typeName); if (classModel.BaseType != null) { sb.AppendFormat(" extends {0}", this.GetFullyQualifiedTypeName(classModel.BaseType)); } var interfaces = classModel.Interfaces.Where(m => CsharpTypeInfoProvider.ExposedInterfaces.Contains(m.Type)).ToList(); if (interfaces.Count > 0) { var implementations = interfaces.Select(GetFullyQualifiedTypeName).ToArray(); var prefixFormat = " implements {0}"; sb.AppendFormat(prefixFormat, string.Join(" ,", implementations)); } sb.AppendLine(" {"); GenerateProperties(classModel, sb, generatorOutput); sb.AppendLineIndented("}"); _generatedClasses.Add(classModel); }
public void WhenCreateFromClass_NameIsSetToTypeNameReturnedByTypeResolver() { var classResolvedType = this.SetupTypeResolverFor <ClassWithoutAttribute>(); var @class = TsClass.CreateFrom <ClassWithoutAttribute>(_typeResolverMock.Object, _configurationProviderMock.Object); Assert.Same(classResolvedType, @class.Name); }
public void WhenInitialized_ConstantsHaveCorrectValues() { var target = new TsClass(typeof(Person)); var maxAddresses = target.Constants.Single(o => o.MemberInfo == typeof(Person).GetField("MaxAddresses")); Assert.Equal(Person.MaxAddresses, maxAddresses.ConstantValue); }
public void WhenCreateFromClassWitoutInterfaces_InterfacesCollectionIsEmpty() { var classResolvedType = this.SetupTypeResolverFor <BaseClass>(); var @class = TsClass.CreateFrom <DerivedClass>(_typeResolverMock.Object, _configurationProviderMock.Object); Assert.Empty(@class.Interfaces); }
public void WhenCreateFromClassWithoutSpecificBaseClass_BaseTypeIsNull() { var baseClassResolvedType = this.SetupTypeResolverFor <BaseClass>(); var objectClassResolvedType = this.SetupTypeResolverFor <object>(); var @class = TsClass.CreateFrom <BaseClass>(_typeResolverMock.Object, _configurationProviderMock.Object); Assert.Null(@class.BaseType); }
public void WhenModuleIsSet_ClassIsAddedToModule() { var module = new TsModule("Tests"); var target = new TsClass(typeof(Address)); target.Module = module; Assert.Contains(target, module.Classes); }
public void WhenCreateFromClassWithBaseClass_BaseTypeIsSetToTypeNameReturnedByTypeResolver() { var classResolvedType = this.SetupTypeResolverFor <DerivedClass>(); var baseClassResolvedType = this.SetupTypeResolverFor <BaseClass>(); var @class = TsClass.CreateFrom <DerivedClass>(_typeResolverMock.Object, _configurationProviderMock.Object); Assert.Same(baseClassResolvedType, @class.BaseType); }
public void WhenInitializedWithClassThatHasBaseClass_OnlyPropertiesDefinedInDerivedClassAreCreated() { var target = new TsClass(typeof(Employee)); Assert.Single(target.Properties.Where(o => o.MemberInfo == typeof(Employee).GetProperty("Salary"))); Assert.Empty(target.Properties.Where(o => o.MemberInfo == typeof(Employee).GetProperty("Street"))); Assert.Empty(target.Properties.Where(o => o.MemberInfo == typeof(Employee).GetProperty("Street"))); }
public void WhenCreateFromClassWithInterfaces_InterfacesCollectionDoesNotContainsInterfacesNotResolvedByTypeResolver() { var classResolvedType = this.SetupTypeResolverFor <ClassWithIntefaces>(); var interface1ResolvedType = this.SetupTypeResolverFor <IInterfaceForClassWithInterfaces>(); var @class = TsClass.CreateFrom <ClassWithIntefaces>(_typeResolverMock.Object, _configurationProviderMock.Object); Assert.Equal(1, @class.Interfaces.Count); Assert.Contains(interface1ResolvedType, @class.Interfaces); }
private string GetNestedClassesString(TsClass netClass) { var nestedClasses = string.Join(_config.NewLines(2), netClass.NestedClasses.Select(WriteType)); if (!string.IsNullOrWhiteSpace(nestedClasses)) { nestedClasses = _config.NewLines(2) + nestedClasses; } return(nestedClasses); }
private void PopulateProperties(TsClass type, IReadOnlyDictionary <Type, TsTypeDefinitionBase> typeDict) { var properties = this._propertyProvider.GetProperties(type.CSharpType); foreach (var propertyInfo in properties) { var propertyType = GetTsType(propertyInfo.PropertyType, typeDict); type.Properties.Add(this._propertyProvider.CreateClassProperty(propertyInfo, propertyType)); } }
public void WhenInitialized_PropertiesCollectionIsEmpty() { var typeName = new TsBasicType() { Context = typeof(ClassWithoutAttribute), TypeName = "ClassWithoutAttribute" }; var sut = new TsClass(typeName); Assert.Empty(sut.Properties); }
public void WhenInitializedWithClassWithEnum_PropertiesCreated() { var target = new TsClass(typeof(Item)); Assert.Single(target.Properties.Where(o => o.MemberInfo == typeof(Item).GetProperty("Type"))); Assert.Single(target.Properties.Where(o => o.MemberInfo == typeof(Item).GetProperty("Id"))); Assert.Single(target.Properties.Where(o => o.MemberInfo == typeof(Item).GetProperty("Name"))); Assert.Null(target.BaseType); }
public void WhenInitialized_NameIsSet() { var typeName = new TsBasicType() { Context = typeof(ClassWithoutAttribute), TypeName = "ClassWithoutAttribute" }; var sut = new TsClass(typeName); Assert.Same(typeName, sut.Name); }
/// <summary> /// /// </summary> /// <param name="classModel"></param> /// <param name="sb"></param> /// <param name="generatorOutput"></param> protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { string typeName = this.GetTypeName(classModel); string visibility = this.GetTypeVisibility(classModel, typeName) ? "export " : ""; sb.AppendFormatIndented("{0}interface {1}", visibility, typeName); if (classModel.BaseType != null) { sb.AppendFormat(" extends {0}", this.GetFullyQualifiedTypeName(classModel.BaseType)); } sb.AppendLine(" {"); var members = new List <TsProperty>(); if ((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) { members.AddRange(classModel.Properties); } if ((generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields) { members.AddRange(classModel.Fields); } using (sb.IncreaseIndentation()) { foreach (var property in members) { if (property.IsIgnored) { continue; } var propTypeName = this.GetPropertyType(property); if (property.PropertyType.IsCollection()) { //Note: new member functon checking if property is collection or not //Also remove the array brackets from the name if (propTypeName.Length > 2 && propTypeName.Substring(propTypeName.Length - 2) == "[]") { propTypeName = propTypeName.Substring(0, propTypeName.Length - 2); } propTypeName = "KnockoutViewModelArray<" + propTypeName + ">"; } else if (property.PropertyType.Type.IsClass && property.PropertyType.Type != typeof(string)) { // KnockoutViewModel does not emit observable objects for classes, it leaves the class in-situ. // It's just value types, collections and strings that are observable. } else { propTypeName = "KnockoutObservable<" + propTypeName + ">"; } sb.AppendLineIndented(string.Format("{0}: {1};", this.GetPropertyName(property), propTypeName)); } } sb.AppendLineIndented("}"); _generatedClasses.Add(classModel); }
public void WhenCreateFromClassWithProperties_PropertiesCollectionContainsProperty() { this.SetupTypeResolverFor <ClassWithProperty>(); this.SetupTypeResolverFor <int>(); var propertyConfiguration = this.SetupConfigurationForMember <ClassWithProperty>("Property"); var @class = TsClass.CreateFrom <ClassWithProperty>(_typeResolverMock.Object, _configurationProviderMock.Object); Assert.Equal(1, @class.Properties.Count); Assert.Equal(propertyConfiguration.Name, @class.Properties[0].Name); }
public void WhenModuleIsSetToOtherModule_ClassIsRemovedFromOriginalModule() { var originalModule = new TsModule("Tests.Original"); var module = new TsModule("Tests"); var target = new TsClass(typeof(Address)); target.Module = originalModule; target.Module = module; Assert.DoesNotContain(target, originalModule.Classes); }
protected override void AppendClassDefinition(TsClass classModel, ScriptBuilder sb, TsGeneratorOutput generatorOutput) { if (classModel.Type.IsInterface && CsharpTypeInfoProvider.ExposedInterfaces.Contains(classModel.Type)) { AppendInterfaceDef(classModel, sb, generatorOutput); } else { AppendClassDef(classModel, sb, generatorOutput); } }