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 TestToCamelCase(string input, string output)
{
// arrange
// act
var actualOutput = SpecFunctions.ToCamelCase(input);
// assert
Assert.Equal(output, actualOutput);
}
public void TestIsSnakeCaseLowerCase(string input, bool output)
{
// arrange
// act
var actualOutput = SpecFunctions.IsSnakeCaseLowerCase(input);
// assert
Assert.Equal(output, actualOutput);
}
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
});
}
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
}
}
});
}
private static string GetFilename(string type, bool appendGeneratedExtension) => SpecFunctions.ToPascalCase(type) + (appendGeneratedExtension ? ".generated" : string.Empty);
public static string GetFileName(string type, bool appendGeneratedExtension) => appendGeneratedExtension ? SpecFunctions.ToHyphenatedCase(type) + ".generated" : SpecFunctions.ToHyphenatedCase(type);
