public void WhenInitialized_ClassesCollectionIsEmpty()
{
var target = new TsModule("Tests");
Assert.NotNull(target.Classes);
Assert.Empty(target.Classes);
}
public IList <TsModule> Generate(ICollection <TsTypeDefinitionBase> types)
{
var modulesForLocation = new Dictionary <TsModuleLocation, TsModule>();
foreach (var type in types)
{
var moduleLocation = this._moduleDivider.GetLocationAndName(type);
if (modulesForLocation.TryGetValue(moduleLocation, out var typeList))
{
typeList.Types.Add(type);
}
else
{
modulesForLocation[moduleLocation] = new TsModule(moduleLocation, new List <TsModuleImport>(), new List <TsTypeDefinitionBase>()
{
type
});
}
}
foreach (var tsModule in modulesForLocation.Values)
{
tsModule.Imports.AddRange(GetReferences(tsModule, modulesForLocation));
}
return(modulesForLocation.Select(x => x.Value).ToList());
}
public TsFile Generate(string rootElement, TsModule module)
{
var builder = new StringBuilder();
foreach (var reference in module.Imports.OrderBy(x => x.Module.GetModuleImport(rootElement)))
{
AddReferences(builder, rootElement, reference);
builder.AppendLine();
}
foreach (var type in module.Types)
{
switch (type)
{
case TsEnum tsEnum:
AddContent(builder, string.Empty, tsEnum);
break;
case TsClass tsClass:
AddContent(builder, string.Empty, tsClass);
break;
case TsInterface tsInterface:
AddContent(builder, string.Empty, tsInterface);
break;
default:
throw new ArgumentException($"Could not generate content for type ({type.Name})");
}
builder.AppendLine();
}
return(new TsFile(builder.ToString(), module.Location.Name, module.Location.Path, module.GeneratesJavascript ? TsFileType.TypeScript : TsFileType.Definition));
}
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 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);
}
/// <summary>
/// Resolves module instance from the module name.
/// </summary>
/// <param name="name">The name of the module</param>
/// <returns></returns>
private TsModule ResolveModule(string name)
{
name = name ?? string.Empty;
if (_modules.ContainsKey(name))
{
return(_modules[name]);
}
var module = new TsModule(name);
_modules[name] = module;
_model.Modules.Add(module);
return(module);
}
public TypeScriptFluent WithModule(string moduleName)
{
TsModule module = new TsModule(moduleName);
foreach (TsClass tsClass in ModelBuilder.Classes.Values)
{
tsClass.Module = module;
}
foreach (TsEnum tsEnum in ModelBuilder.Enums.Values)
{
tsEnum.Module = module;
}
return(this);
}
protected virtual void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
List <TsClass> classesByName = module.Classes.Where(c => !_typeConvertors.IsConvertorRegistered(c.Type) && !c.IsIgnored).OrderBy(c => GetTypeName(c)).ToList();
List <TsClass> classes = SortByDependency(classesByName);
var enums = module.Enums.Where(e => !_typeConvertors.IsConvertorRegistered(e.Type) && !e.IsIgnored).OrderBy(e => GetTypeName(e)).ToList();
if ((generatorOutput == TsGeneratorOutput.Enums && enums.Count == 0) ||
(generatorOutput == TsGeneratorOutput.Properties && classes.Count == 0) ||
(enums.Count == 0 && classes.Count == 0))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Constants && !classes.Any(c => c.Constants.Any()))
{
return;
}
var moduleName = GetModuleName(module);
var generateModuleHeader = moduleName != string.Empty;
if (generateModuleHeader)
{
if (generatorOutput != TsGeneratorOutput.Enums &&
(generatorOutput & TsGeneratorOutput.Constants) != TsGeneratorOutput.Constants)
{
sb.Append(Mode == TsGenerationModes.Definitions ? "declare " : " export ");
}
sb.AppendLine($"{(Mode == TsGenerationModes.Definitions ? "namespace" : "module")} {moduleName} {{");
using (sb.IncreaseIndentation())
{
GenerateModuleContent(sb, generatorOutput, classes, enums);
}
sb.AppendLine("}");
}
else
{
GenerateModuleContent(sb, generatorOutput, classes, enums);
}
}
public virtual string WriteModule(TsModule netModule, bool isTopLevelDeclareNamespace)
{
var typeDeclarationsContent = string.Join(_config.NewLines(2), netModule.TypeDeclarations.Select(WriteType));
var functionDeclarationsContent = string.Join(_config.NewLines(2), netModule.FunctionDeclarations.Select(fd => WriteMethod(fd, true)));
var namespaceDeclarationsContent = string.Join(_config.NewLines(2), netModule.Namespaces.Select(ns => WriteNamespace(ns, false)));
var fieldDeclarationsContent = string.Join(_config.NewLines(2), netModule.FieldDeclarations.Select(fd => WriteFieldDeclaration(fd)));
var content = JoinNonEmpty(_config.NewLines(2), typeDeclarationsContent, functionDeclarationsContent, namespaceDeclarationsContent, fieldDeclarationsContent);
if (!string.IsNullOrWhiteSpace(content))
{
content = content.Indent(_indent) + _config.NewLine;
}
var declare = isTopLevelDeclareNamespace ? "declare " : "";
var export = netModule.IsExport ? "export " : "";
return($@"{declare}{export}module {netModule.Name}" + _config.NewLine +
@"{" + _config.NewLine +
content +
@"}");
}
private IList <TsModuleImport> GetReferences(TsModule module, IReadOnlyDictionary <TsModuleLocation, TsModule> modulesForLocation)
{
var referenceDict = new Dictionary <TsModule, List <TsTypeDefinitionBase> >();
foreach (var type in module.Types)
{
foreach (var typeDefinitionReference in GetTypeDefinitionReferences(type).Except(module.Types))
{
var currentModule = modulesForLocation[this._moduleDivider.GetLocationAndName(typeDefinitionReference)];
if (referenceDict.TryGetValue(currentModule, out var types))
{
types.Add(typeDefinitionReference);
}
else
{
referenceDict[currentModule] = new List <TsTypeDefinitionBase> {
typeDefinitionReference
};
}
}
}
return(referenceDict.Select(kvp => new TsModuleImport(kvp.Key, kvp.Value)).ToList());
}
public string DefaultModuleNameFormatter(TsModule module)
{
return(module.Name);
}
/// <summary>
/// Formats a module name
/// </summary>
/// <param name="module">The module to be formatted</param>
/// <returns>The module name after formatting.</returns>
public string GetModuleName(TsModule module)
{
return(_moduleNameFormatter(module));
}
protected virtual void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
var classes = module.Classes.Where(c => !_typeConvertors.IsConvertorRegistered(c.Type) && !c.IsIgnored).OrderBy(c => GetTypeName(c)).ToList();
var enums = module.Enums.Where(e => !_typeConvertors.IsConvertorRegistered(e.Type) && !e.IsIgnored).OrderBy(e => GetTypeName(e)).ToList();
if ((generatorOutput == TsGeneratorOutput.Enums && enums.Count == 0) ||
(generatorOutput == TsGeneratorOutput.Properties && classes.Count == 0) ||
(enums.Count == 0 && classes.Count == 0))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Properties && !classes.Any(c => c.Fields.Any() || c.Properties.Any()))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Constants && !classes.Any(c => c.Constants.Any()))
{
return;
}
var moduleName = GetModuleName(module);
var generateModuleHeader = moduleName != string.Empty;
if (generateModuleHeader)
{
if (generatorOutput != TsGeneratorOutput.Enums &&
(generatorOutput & TsGeneratorOutput.Constants) != TsGeneratorOutput.Constants)
{
sb.Append("declare ");
}
sb.AppendLine(string.Format("namespace {0} {{", moduleName));
}
using (sb.IncreaseIndentation()) {
if ((generatorOutput & TsGeneratorOutput.Enums) == TsGeneratorOutput.Enums)
{
foreach (var enumModel in enums)
{
this.AppendEnumDefinition(enumModel, sb, generatorOutput);
}
}
if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) ||
(generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields)
{
foreach (var classModel in classes)
{
this.AppendClassDefinition(classModel, sb, generatorOutput);
}
}
if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants)
{
foreach (var classModel in classes)
{
if (classModel.IsIgnored)
{
continue;
}
this.AppendConstantModule(classModel, sb);
}
}
}
if (generateModuleHeader)
{
sb.AppendLine("}");
}
}
/// <summary>
/// When overridden in a derived class, it can examine or modify the script module.
/// </summary>
/// <param name="module">The module being visited.</param>
public virtual void VisitModule(TsModule module)
{
}
protected override void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
var classes = module.Classes.Where(c => !_typeConvertors.IsConvertorRegistered(c.Type) && !c.IsIgnored).ToList();
var enums = module.Enums.Where(e => !_typeConvertors.IsConvertorRegistered(e.Type) && !e.IsIgnored).ToList();
if ((generatorOutput == TsGeneratorOutput.Enums && enums.Count == 0) ||
(generatorOutput == TsGeneratorOutput.Properties && classes.Count == 0) ||
(enums.Count == 0 && classes.Count == 0))
{
return;
}
if ((generatorOutput & TsGeneratorOutput.Enums) == TsGeneratorOutput.Enums)
{
foreach (var enumModel in enums)
{
if (Ignore(enumModel))
{
continue;
}
this.AppendEnumDefinition(enumModel, sb, generatorOutput);
}
}
if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) ||
(generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields)
{
var cc = classes.Select(c => new { c, order = OrderTypes(c) }).ToList();
var orderedClasses = cc.OrderBy(c => c.order).ToList();
foreach (var oc in orderedClasses)
{
var classModel = oc.c;
var t = classModel.Type;
// var x = $"// {oc.order} - {oc.c.Type.FullName}";
// sb.AppendIndented(x);
if (t.IsInterface && !CsharpTypeInfoProvider.ExposedInterfaces.Contains(t) && CsharpTypeInfoProvider.ExposedInterfaces.Any(i => i.IsAssignableFrom(t)))
{
continue;
}
var c = ReMapClass(classModel);
if (Ignore(c))
{
continue;
}
if (this._appended.Contains(c.Name))
{
continue;
}
if (this._appended.Contains("I" + c.Name))
{
continue;
}
this.AppendClassDefinition(c, sb, generatorOutput);
this._appended.Add(c.Name);
}
}
if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants)
{
foreach (var classModel in classes)
{
if (classModel.IsIgnored)
{
continue;
}
this.AppendConstantModule(classModel, sb);
}
}
}
public override void WriteModuleContent(StringBuilder result, TsModule module)
{
result.Append(" 'use strict';\r\n");
base.WriteModuleContent(result, module);
}
protected override void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
// Use reflection to grab the internal property which was removed!
var typeConverters = (TypeConvertorCollection)_typeConvertersMember.GetValue(this);
var classes = module.Classes.Where(c => !typeConverters.IsConvertorRegistered(c.Type) && !c.IsIgnored)
// .OrderBy(c => GetTypeName(c)) // Sorting breaks inheritance
.ToList();
var baseClasses = classes
.Where(c => c.BaseType != null)
.Select(c => c.BaseType.Type.FullName)
.Distinct()
.OrderBy(c => c)
.ToList();
var enums = module.Enums.Where(e => !typeConverters.IsConvertorRegistered(e.Type) && !e.IsIgnored).OrderBy(e => GetTypeName(e)).ToList();
if ((generatorOutput == TsGeneratorOutput.Enums && enums.Count == 0) ||
(generatorOutput == TsGeneratorOutput.Properties && classes.Count == 0) ||
(enums.Count == 0 && classes.Count == 0))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Properties && !classes.Any(c => c.Fields.Any() || c.Properties.Any()))
{
return;
}
if (generatorOutput == TsGeneratorOutput.Constants && !classes.Any(c => c.Constants.Any()))
{
return;
}
string moduleName = GetModuleName(module);
bool generateModuleHeader = moduleName != string.Empty;
if (generateModuleHeader)
{
if (generatorOutput != TsGeneratorOutput.Enums &&
(generatorOutput & TsGeneratorOutput.Constants) != TsGeneratorOutput.Constants)
{
sb.Append(Mode == TsGenerationModes.Definitions ? "declare " : " export ");
}
sb.AppendLine($"{(Mode == TsGenerationModes.Definitions ? "namespace" : "module")} {moduleName} {{");
}
using (sb.IncreaseIndentation())
{
if ((generatorOutput & TsGeneratorOutput.Enums) == TsGeneratorOutput.Enums)
{
foreach (TsEnum enumModel in enums)
{
this.AppendEnumDefinition(enumModel, sb, generatorOutput);
}
}
if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) ||
(generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields)
{
foreach (TsClass baseClassModel in classes.Where(c => baseClasses.Contains(c.Type.FullName)))
{
this.AppendClassDefinition(baseClassModel, sb, generatorOutput);
}
}
if (((generatorOutput & TsGeneratorOutput.Properties) == TsGeneratorOutput.Properties) ||
(generatorOutput & TsGeneratorOutput.Fields) == TsGeneratorOutput.Fields)
{
foreach (TsClass classModel in classes.Where(c => !baseClasses.Contains(c.Type.FullName)))
{
this.AppendClassDefinition(classModel, sb, generatorOutput);
}
}
if ((generatorOutput & TsGeneratorOutput.Constants) == TsGeneratorOutput.Constants)
{
foreach (TsClass classModel in classes)
{
if (classModel.IsIgnored)
{
continue;
}
this.AppendConstantModule(classModel, sb);
}
}
}
if (generateModuleHeader)
{
sb.AppendLine("}");
}
}
public void WhenInitialized_NameIsSet()
{
var target = new TsModule("Tests");
Assert.Equal("Tests", target.Name);
}
protected override void AppendModule(TsModule module, ScriptBuilder sb, TsGeneratorOutput generatorOutput)
{
base.AppendModule(module, sb, generatorOutput);
}