private static GeneratorOutput GenerateEnum(Spec spec, string @enum) { var targetInfo = spec.Targets[Constants.TypeScriptTarget]; var enumFileName = TypeScriptFileUtilities.GetFileName(@enum, targetInfo.AppendGeneratedExtension); var enumMembers = spec.Enums[@enum]; var normalizedEnumName = SpecFunctions.ToPascalCase(@enum); var members = new List <TypeScriptEnumMember>(enumMembers.Count); for (int i = 0; i < enumMembers.Count; i++) { members.Add(GenerateEnumMember(enumMembers[i])); } return(new GeneratorOutput { Path = Path.Combine(targetInfo.Path, enumFileName + "." + Constants.TypeScriptExtension), GenerationRoot = new TypeScriptFile { Contents = new List <TypeScriptDeclarationOrStatement> { new TypeScriptEnum { Name = normalizedEnumName, Members = members }, new TypeScriptExportStatement { IsDefault = true, Object = normalizedEnumName } } } }); }
private static CSharpEnumMember GenerateEnumMember(EnumMember member) { return(new CSharpEnumMember { Name = SpecFunctions.ToPascalCase(member.Name), Value = member.Value }); }
public void TestToPascalCase(string input, string output) { // arrange // act var actualOutput = SpecFunctions.ToPascalCase(input); // assert Assert.Equal(output, actualOutput); }
public static CSharpClass GenerateEntity(Spec spec, string entity) { var entityMembers = spec.Entities[entity].Members; var members = new List <CSharpClassMember>(entityMembers.Count); foreach (var entityMember in (IDictionary <string, IEntityMemberInfo>)entityMembers) { members.Add(CSharpEntityMemberGenerator.GenerateEntityMember(spec, entity, entityMember.Key)); } return (new CSharpClass { Name = SpecFunctions.ToPascalCase(entity), Members = members }); }
public static CSharpClassMember GenerateEntityMember(Spec spec, string entity, string member) { var memberInfo = spec.Entities[entity].Members[member]; var resolvedType = spec.GetResolvedType(Constants.CSharpTarget, memberInfo.Type); var implementationType = CSharpFacts.IsNativeType(resolvedType) ? resolvedType : SpecFunctions.ToPascalCase(resolvedType); var isValueType = CSharpFacts.IsStructNativeType(implementationType) || spec.Enums.ContainsKey(resolvedType); var memberType = memberInfo.IsCollection ? "IList<" + implementationType + ">" : implementationType + (memberInfo.IsNullable && isValueType ? "?" : string.Empty); var memberName = SpecFunctions.ToPascalCase(member); var isString = resolvedType == "string"; var implementationNamespace = GetImplementationTypeNamespace(implementationType); var namespaces = (IList <string>)null; if (implementationNamespace != null) { namespaces = new List <string> { implementationNamespace }; if (memberInfo.IsCollection) { namespaces.AddIfNotExists("System.Collections.Generic"); } } else if (memberInfo.IsCollection) { namespaces = new List <string> { "System.Collections.Generic" }; } return(new CSharpClassMember { Namespaces = namespaces, Type = memberType, Name = memberName, RequiredAttributeBehavior = !memberInfo.IsNullable && !isValueType ? isString ? CSharpRequiredAttributeBehavior.IssueRequiredAllowEmptyStrings : CSharpRequiredAttributeBehavior.IssueRequired : CSharpRequiredAttributeBehavior.NoRequiredAttribute }); }
public static TypeScriptClass GenerateEntity(Spec spec, string entityName) { var entityMembers = (IDictionary <string, IEntityMemberInfo>)spec.Entities[entityName].Members; var members = new List <TypeScriptClassMember>(entityMembers.Count); foreach (var entityMember in entityMembers) { if (!entityMember.Value.Exclude.Contains(Constants.TypeScriptTarget)) { members.Add(TypeScriptEntityMemberGenerator.GenerateEntityMember(spec, entityMember)); } } return(new TypeScriptClass { Name = SpecFunctions.ToPascalCase(entityName), Members = members }); }
public static IEnumerable <TypeScriptDeclarationOrStatement> GetImportStatementsForEntity(Spec spec, string entityName) { var targetInfo = spec.Targets[Constants.TypeScriptTarget]; var enumDependencies = spec.GetDirectEnumDependencies(Constants.TypeScriptTarget, entityName); var entityDependencies = spec.GetDirectEntityDependencies(Constants.TypeScriptTarget, entityName); foreach (var @enum in enumDependencies) { yield return(new TypeScriptImportStatement { ObjectName = SpecFunctions.ToPascalCase(@enum), File = TypeScriptFileUtilities.GetFileName(@enum, targetInfo.AppendGeneratedExtension) }); } foreach (var entity in entityDependencies) { yield return(new TypeScriptImportStatement { ObjectName = SpecFunctions.ToPascalCase(entity), File = TypeScriptFileUtilities.GetFileName(entity, targetInfo.AppendGeneratedExtension) }); } }
private static IGenerationRoot GenerateEnum(Spec spec, string enumName) { var enumMembers = spec.Enums[enumName]; var members = new List <CSharpEnumMember>(enumMembers.Count); foreach (var member in enumMembers) { members.Add(GenerateEnumMember(member)); } return(new CSharpNamespace { Name = spec.Targets[Constants.CSharpTarget].Namespace, Types = new List <CSharpType> { new CSharpEnum { Name = SpecFunctions.ToPascalCase(enumName), Members = members } } }); }
public static TypeScriptClassMember GenerateEntityMember(Spec spec, KeyValuePair <string, IEntityMemberInfo> member) { var resolvedType = spec.GetResolvedType(Constants.TypeScriptTarget, member.Value.Type); var normalizedType = TypeScriptFacts.IsNativeType(resolvedType) ? resolvedType : SpecFunctions.ToPascalCase(resolvedType); var normalizedMemberName = SpecFunctions.ToCamelCase(member.Key); if (member.Value.IsCollection) { normalizedType += "[]"; } return(new TypeScriptClassMember { Name = normalizedMemberName, Type = normalizedType }); }
private static string GetFilename(string type, bool appendGeneratedExtension) => SpecFunctions.ToPascalCase(type) + (appendGeneratedExtension ? ".generated" : string.Empty);