public override IEnumerable <INotation> AfterMethod(ProxyGeneratorContext context, IMethodSymbolInfo method)
{
if (method.HasReturnValue)
{
yield return($"System.Console.WriteLine($\"return {{{context.GetReturnValueParameterName()}}} at {{System.DateTime.Now.ToString(\"yyyy-MM-dd HH:mm:ss.fff\")}}\");".ToNotation());
}
}
public void EmitClosedGenericAsFreeType()
{
var context = new ProxyGeneratorContext(new[] { typeof(GenericClass <int>) }, new Configuration());
Assert.Contains(
@"export module Cirqus.TypeScript.Tests {
export interface GenericClass<T> {
}
}
", context.GetDefinitions(CirqusType.Other));
}
public void IgnoresMarkedProperties()
{
var context = new ProxyGeneratorContext(new[] { typeof(ClassWithIgnoredProperty) }, new Configuration());
Assert.Contains(
@"export module Cirqus.TypeScript.Tests {
export interface ClassWithIgnoredProperty {
}
}
", context.GetDefinitions(CirqusType.Other));
}
public void EmitOpenGenericTypesWithMultipleParams()
{
var context = new ProxyGeneratorContext(new[] { typeof(GenericClass <,>) }, new Configuration());
Assert.Contains(
@"export module Cirqus.TypeScript.Tests {
export interface GenericClass<T, U> {
}
}
", context.GetDefinitions(CirqusType.Other));
}
public void EmitEnumerableGenericTypesClosedWithTypeArgument()
{
var context = new ProxyGeneratorContext(new[] { typeof(MotherOfEnumerableOf <>) }, new Configuration());
Assert.Contains(
@"export module Cirqus.TypeScript.Tests {
export interface MotherOfEnumerableOf<T> {
type: T[];
}
}
", context.GetDefinitions(CirqusType.Other));
}
public override IEnumerable <INotation> BeforeMethod(ProxyGeneratorContext context, IMethodSymbolInfo method)
{
if (!method.Parameters.IsEmpty)
{
yield return($"System.Console.WriteLine($\"Call Method {method.Name} at {{System.DateTime.Now.ToString(\"yyyy-MM-dd HH:mm:ss.fff\")}} {method.Parameters.First().Type.FullName} {method.Parameters.First().Name} = {{{method.Parameters.First().Name}}}".ToNotation());
foreach (var item in method.Parameters.Skip(1))
{
yield return($", {item.FullName} {item.Name} = {{{item.Name}}}".ToNotation());
}
yield return("\");".ToNotation());
}
}
public IEnumerable <ProxyGenerationResult> GetProxyGenerationResults(Configuration configuration)
{
var types = configuration.Types;
Console.WriteLine("Found {0} types", types.Count);
var context = new ProxyGeneratorContext(types, configuration);
var apiCode = context.GetDefinitions(CirqusType.Command, CirqusType.View, CirqusType.Other, CirqusType.Primitive);
var systemCode = context.GetSystemDefinitions();
yield return(new ProxyGenerationResult(apiCode + systemCode));
}
public override IEnumerable <INotation> AfterProperty(ProxyGeneratorContext context, IPropertySymbolInfo property, IMethodSymbolInfo method)
{
if (method.HasReturnValue)
{
var r = context.GetReturnValueParameterName();
var rType = method.ReturnType;
if (rType.IsType <int>())
{
yield return(r.ToNotation());
yield return("-=5;".ToNotation());
}
}
}
public IEnumerable <INotation> BeforeMethod(ProxyGeneratorContext context)
{
switch (context.Symbol)
{
case IMethodSymbolInfo method:
return(BeforeMethod(context, method));
case IPropertySymbolInfo property:
return(BeforeProperty(context, property, context.GetCurrentPropertyMethod()));
default:
return(ConstNotations.Nothings);
}
}
public void EmitsEnumWithImplicitValues()
{
var context = new ProxyGeneratorContext(new[] { typeof(Enum) }, new Configuration());
Assert.Contains(
@"
export module Cirqus.TypeScript.Tests {
export enum Enum {
None = 0,
Value1 = 1,
Value2 = 2
}
}
", context.GetDefinitions(CirqusType.Other));
}
public void EmitOpenGenericTypesWithTypeArgumentProperty()
{
var context = new ProxyGeneratorContext(new[] { typeof(GenericClassWithTypeArgumentProperty <>) },
new Configuration());
Assert.Contains(
@"
export module Cirqus.TypeScript.Tests {
export interface GenericClassWithTypeArgumentProperty<T> {
item: T;
}
}
", context.GetDefinitions(CirqusType.Other));
Assert.DoesNotContain(@"export class T", context.GetDefinitions(CirqusType.Other));
}
public void CanAliasNamespaces()
{
var context = new ProxyGeneratorContext(new[] { typeof(SomeClass) }, new Configuration()
{
NamespaceAliases =
{
Tuple.Create("Cirqus.TypeScript", "HAT")
}
});
Assert.Contains(
@"export module HAT.Tests {
export interface SomeClass {
}
}
", context.GetDefinitions(CirqusType.Other));
}
public void EmitClosedGenericAsUsedType()
{
var context = new ProxyGeneratorContext(new[] { typeof(FatherOfGenericClass) }, new Configuration());
Assert.Contains(
@"export module Cirqus.TypeScript.Tests {
export interface FatherOfGenericClass {
type: Cirqus.TypeScript.Tests.GenericClass<number>;
}
}
export module Cirqus.TypeScript.Tests {
export interface GenericClass<T> {
}
}
", context.GetDefinitions(CirqusType.Other));
}
public void CommandIsExportedAsClassAndMetaDataIsIgnored()
{
var context = new ProxyGeneratorContext(new[] { typeof(CommandClass) }, new Configuration());
Assert.Contains(
@"export module Cirqus.TypeScript.Tests {
export class CommandClass implements Command {
constructor(args: {prop: number}) {
this.prop = args.prop;
}
$commandType = ""Cirqus.TypeScript.Tests.CommandClass, Cirqus.TypeScript.Tests"";
$commandName = ""CommandClass"";
prop: number;
}
}
", context.GetDefinitions(CirqusType.Command));
}
public void EmitsEnumFromNullableProperty()
{
var context = new ProxyGeneratorContext(new[] { typeof(ClassWithEnum) }, new Configuration());
Assert.Contains(
@"
export module Cirqus.TypeScript.Tests {
export interface ClassWithEnum {
enum: Cirqus.TypeScript.Tests.Enum;
}
}
export module Cirqus.TypeScript.Tests {
export enum Enum {
None = 0,
Value1 = 1,
Value2 = 2
}
}
", context.GetDefinitions(CirqusType.Other));
}
IEnumerable <ProxyGenerationResult> GetProxyGenerationResults()
{
var commandTypes = _sourceDlls
.Select(LoadAssembly)
.SelectMany(GetTypes)
.Where(ProxyGeneratorContext.IsCommand)
.ToList();
_writer.Print("Found {0} command types", commandTypes.Count);
var commandsFileName = string.Format("commands.ts");
var commandProcessorFileName = string.Format("commandProcessor.ts");
var context = new ProxyGeneratorContext(commandTypes);
var code = context.GetCommandDefinitations();
yield return(new ProxyGenerationResult(commandsFileName, _writer, code));
var moreCode = context.GetCommandProcessorDefinitation();
yield return(new ProxyGenerationResult(commandProcessorFileName, _writer, moreCode));
}
public virtual IEnumerable <INotation> AfterProperty(ProxyGeneratorContext context, IPropertySymbolInfo property, IMethodSymbolInfo method) => ConstNotations.Nothings;
public virtual IEnumerable <INotation> BeforeMethod(ProxyGeneratorContext context, IMethodSymbolInfo method) => ConstNotations.Nothings;
