protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
byte[] mainFileBytes = null;
var targetItem = Dte.Solution.FindProjectItem(inputFileName);
if (targetItem != null)
{
var targetFileInfo = new FileInfo(targetItem.FileNames[0]);
var resxResults = GetRelatedFilesNames(inputFileName).Select(x => resxResultProvider.GetResult(x));
List <string> generatedFileNames = new List <string>();
ResxResult structureItem = null;
foreach (var item in resxResults)
{
var fileName = GetFileName(targetFileInfo, item);
if (item.IsDefault)
{
structureItem = item;
using (var ms = new MemoryStream())
{
resxTypeScriptGenerator.Generate(ms, FileNamespace, structureItem, item);
mainFileBytes = ms.ToArray();
}
}
else
{
using (var fs = File.Open(fileName, FileMode.Create, FileAccess.Write))
{
resxTypeScriptGenerator.Generate(fs, FileNamespace, structureItem, item);
}
// only add the file to the project for localized files
// visual studio handles the addition of the default file
targetItem.ProjectItems.AddFromFile(fileName);
}
generatedFileNames.Add(fileName);
}
// ensure only generated files are child-items
foreach (ProjectItem item in targetItem.ProjectItems)
{
if (!generatedFileNames.Contains(item.FileNames[0]))
{
item.Delete();
}
}
}
return(mainFileBytes);
}
protected string[] GenerateCode(TypeScriptGenerationOptions options, ICustomTypeGenerator customTypeGenerator, Type rootType)
{
var generator = new TypeScriptGenerator(options, customTypeGenerator, new TypesProvider(rootType));
if (JavaScriptTypeChecker == JavaScriptTypeChecker.Flow && options.EnumGenerationMode == EnumGenerationMode.TypeScriptEnum)
throw new ArgumentException("Invalid EnumGenerationMode for JavaScriptTypeChecker.Flow");
return generator.Generate().Select(x => x.GenerateCode(new DefaultCodeGenerationContext(JavaScriptTypeChecker)).Replace("\r\n", "\n")).ToArray();
}
private static void TryGenerate(Func <string, string> pluralize)
{
var options = TypeScriptGenerationOptions.Default;
options.Pluralize = pluralize;
var generator = new TypeScriptGenerator(options, CustomTypeGenerator.Null, TypesProvider.Default);
generator.Generate();
}
private static string[] GenerateCode(Type rootType)
{
var generator = new TypeScriptGenerator(new TypeScriptGenerationOptions {
EnumGenerationMode = EnumGenerationMode.FixedStringsAndDictionary
},
CustomTypeGenerator.Null, new RoslynTypesProvider(rootType.FullName));
return(generator.Generate().Select(x => x.GenerateCode(new DefaultCodeGenerationContext(JavaScriptTypeChecker.TypeScript)).Replace("\r\n", "\n")).ToArray());
}
static void Main(string[] args)
{
var provider = new ResxResultProvider();
var result = provider.GetResult("Testresources.resx");
var generator = new TypeScriptGenerator();
var output = generator.Generate("anx.localized", result);
}
public void TypescriptGenerator_HandlesCollectionsSuitably()
{
var generator = new TypeScriptGenerator();
var actual = generator.Generate(new List <Type> {
typeof(CollectionTestClasses.CollectionTestClass)
});
var expected = Results.Resources.CollectionTest;
StringAssert.HaveTrimmedContent(expected, actual);
}
public void TypescriptGenerator_GeneratesWorkingTypescript()
{
var generator = new TypeScriptGenerator();
var actual = generator.Generate(new List <Type> {
typeof(NamespaceOfTestClasses.Subclass)
});
var expected = Results.Resources.TypeScriptResult;
StringAssert.HaveTrimmedContent(expected, actual);
}
private static void GenerateSource(Options options)
{
var inputPaths = new List <string>();
if (options.InputFiles != null)
{
inputPaths.AddRange(options.InputFiles);
}
if (options.InputDirectories != null)
{
var searchOptions = options.RecursiveInputDirectories
? SearchOption.AllDirectories
: SearchOption.TopDirectoryOnly;
inputPaths.AddRange(options.InputDirectories
.SelectMany(path => Directory.EnumerateFiles(path, "*.cs", searchOptions)));
}
var useStdOut = string.IsNullOrEmpty(options.OutputDirectory);
var inputFiles = inputPaths.Select(File.ReadAllText).ToArray();
var output = useStdOut ? (TextWriter) new StringWriter() : new StreamWriter(options.OutputDirectory);
var generator = new TypeScriptGenerator(output)
{
CustomTypePrefix = options.TypePrefix,
ConvertFieldsToCamelCase = options.MakeCamelCase,
ConvertClassesToInterfaces = options.MakeInterfaces,
MakeEnumConst = options.ConstEnum,
};
if (options.Verbose)
{
generator.OnUnhandledSyntaxNode += node => Console.Error.WriteLine($"[WARNING] Unhandled syntax node {node.Kind()}");
}
generator.ArrayTypeNames.UnionWith(options.ArrayTypes);
foreach (var typeConversion in options.AliasTypes)
{
var types = typeConversion.Split(':');
var csharp = types.Length >= 1 ? types[0] : "???";
var typescript = types.Length >= 2 ? types[1] : "???";
generator.TypeNameConversions[csharp] = typescript;
}
generator.Generate(inputFiles);
if (useStdOut)
{
Console.WriteLine(output);
}
output.Close();
}
public static void AssertEqual(string input, string expectedOutput, Action <TypeScriptGenerator> options = null)
{
var sb = new StringBuilder();
var generator = new TypeScriptGenerator(new StringWriter(sb));
options?.Invoke(generator);
generator.Generate(input);
var expexted = NormalizeTypescriptSource(expectedOutput);
var actual = NormalizeTypescriptSource(sb.ToString());
Assert.AreEqual(expexted, actual);
}
public void CustomGeneratorBuilderTest()
{
var(customGenerator, typesProvider) = GetCustomization <TTypesProvider>(typeof(BuilderCustomGenerator), typeof(ArrayRootType));
var generator = new TypeScriptGenerator(TypeScriptGenerationOptions.Default, customGenerator, typesProvider);
var units = generator.Generate();
var code = units.Select(x => x.GenerateCode(new DefaultCodeGenerationContext()).Replace("\r\n", "\n")).ToArray();
units.Select(x => x.Path).Should().Equal("", "a/b/c");
var expectedCodeRoot = GetExpectedCode("CustomGenerator/custom-generator-builder");
var expectedCodeChild = GetExpectedCode("CustomGenerator/custom-generator-builder-child");
code.Length.Should().Be(2);
code[0].Diff(expectedCodeRoot).ShouldBeEmpty();
code[1].Diff(expectedCodeChild).ShouldBeEmpty();
}
public void CustomGeneratorBuilderTest()
{
var customGenerator = new CustomTypeGenerator()
.WithTypeLocation<AnotherCustomType>(x => "a/b/c")
.WithTypeRedirect<byte[]>("ByteArray", @"DataTypes\ByteArray")
.WithTypeBuildingContext<HashSet<string>>(x => new CollectionTypeBuildingContext(x));
var generator = new TypeScriptGenerator(TypeScriptGenerationOptions.Default, customGenerator, new RootTypesProvider(typeof(ArrayRootType)));
var units = generator.Generate();
var code = units.Select(x => x.GenerateCode(new DefaultCodeGenerationContext(JavaScriptTypeChecker)).Replace("\r\n", "\n")).ToArray();
units.Select(x => x.Path).Should().Equal("", "a/b/c");
var expectedCodeRoot = GetExpectedCode("CustomGenerator/custom-generator-builder");
var expectedCodeChild = GetExpectedCode("CustomGenerator/custom-generator-builder-child");
code.Length.Should().Be(2);
code[0].Diff(expectedCodeRoot).ShouldBeEmpty();
code[1].Diff(expectedCodeChild).ShouldBeEmpty();
}
public static void AssertGenerator(TypeInfo[] input, string expectedOuput, Action <TypeScriptGenerator> options = null)
{
string Normalize(string value)
{
var whitespace = new Regex(@"\s+");
return(whitespace.Replace(value, ""));
}
var writer = new StringWriter();
var generator = new TypeScriptGenerator(writer);
options?.Invoke(generator);
generator.Generate(input);
var actual = Normalize(writer.ToString());
var expected = Normalize(expectedOuput);
Assert.AreEqual(expected, actual);
}
protected string[] GenerateCode(TypeScriptGenerationOptions options, ICustomTypeGenerator customTypeGenerator, IRootTypesProvider typesProvider)
{
var generator = new TypeScriptGenerator(options, customTypeGenerator, typesProvider);
return(generator.Generate().Select(x => x.GenerateCode(new DefaultCodeGenerationContext()).Replace("\r\n", "\n")).ToArray());
}
private static string[] GenerateCode(Type rootType)
{
var generator = new TypeScriptGenerator(TypeScriptGenerationOptions.Default, CustomTypeGenerator.Null, new RoslynTypesProvider(rootType.FullName));
return(generator.Generate().Select(x => x.GenerateCode(new DefaultCodeGenerationContext()).Replace("\r\n", "\n")).ToArray());
}
