public override void Visit(RtJsdocNode node)
{
if (node == null)
{
return;
}
if (!string.IsNullOrEmpty(node.Description) && !node.Description.Contains("\n") && node.TagToDescription.Count == 0)
{
//handle single-line JSDOC
AppendTabs(); Write("/** "); Write(node.Description); WriteLine(" */");
}
else
{
AppendTabs(); WriteLine("/**");
if (!string.IsNullOrEmpty(node.Description))
{
Summary(node.Description);
if (node.TagToDescription.Count > 0)
{
DocLine();
}
}
foreach (var tuple in node.TagToDescription)
{
DocTag(tuple.Item1, tuple.Item2);
}
AppendTabs(); WriteLine("*/");
}
}
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtFuncion GenerateNode(MethodInfo element, RtFuncion result, TypeResolver resolver)
{
if (element.IsIgnored())
{
return(null);
}
string name;
RtTypeName type;
GetFunctionNameAndReturnType(element, resolver, out name, out type);
result.Identifier = new RtIdentifier(name);
result.ReturnType = type;
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode jsdoc = new RtJsdocNode {
Description = doc.Summary.Text
};
if (doc.Parameters != null)
{
foreach (var documentationParameter in doc.Parameters)
{
jsdoc.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Param,
documentationParameter.Name + " " + documentationParameter.Description));
}
}
if (doc.HasReturns())
{
jsdoc.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Returns, doc.Returns.Text));
}
result.Documentation = jsdoc;
}
result.AccessModifier = element.GetModifier();
if (Context.SpecialCase)
{
result.AccessModifier = AccessModifier.Public;
}
result.Identifier = new RtIdentifier(name);
result.IsStatic = element.IsStatic;
var p = element.GetParameters();
foreach (var param in p)
{
if (param.IsIgnored())
{
continue;
}
var generator = resolver.GeneratorFor(param, Context);
var argument = generator.Generate(param, resolver);
result.Arguments.Add((RtArgument)argument);
}
return(result);
}
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtEnum GenerateNode(Type element, RtEnum result, TypeResolver resolver)
{
var names = Enum.GetNames(element);
result.EnumName = element.GetName();
result.Order = element.GetOrder();
var fields = element.GetFields().Where(c => !c.IsSpecialName).ToDictionary(c => c.Name, c => c);
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode docNode = new RtJsdocNode();
if (doc.HasSummary())
{
docNode.Description = doc.Summary.Text;
}
result.Documentation = docNode;
}
List <RtEnumValue> valuesResult = new List <RtEnumValue>();
for (var index = 0; index < names.Length; index++)
{
var n = names.GetValue(index) as string;
var v = Enum.Parse(element, n);
if (fields.ContainsKey(n))
{
var fieldItself = fields[n];
var attr = ConfigurationRepository.Instance.ForEnumValue(fieldItself);
if (attr != null)
{
n = attr.Name;
}
RtEnumValue value = new RtEnumValue
{
EnumValueName = n,
EnumValue = Convert.ToInt64(v).ToString()
};
var valueDoc = Context.Documentation.GetDocumentationMember(fieldItself);
if (valueDoc != null)
{
RtJsdocNode docNode = new RtJsdocNode();
if (doc.HasSummary())
{
docNode.Description = valueDoc.Summary.Text;
}
value.Documentation = docNode;
}
valuesResult.Add(value);
}
}
result.Values.AddRange(valuesResult);
AddDecorators(result, ConfigurationRepository.Instance.DecoratorsFor(element));
return(result);
}
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtConstructor GenerateNode(ConstructorInfo element, RtConstructor result, TypeResolver resolver)
{
if (Context.CurrentBlueprint.IsIgnored(element))
{
return(null);
}
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode jsdoc = new RtJsdocNode();
if (doc.HasInheritDoc())
{
jsdoc.AddTag(DocTag.Inheritdoc);
}
if (doc.HasSummary())
{
jsdoc.Description = doc.Summary.Text;
}
if (doc.Parameters != null)
{
foreach (var documentationParameter in doc.Parameters)
{
jsdoc.AddTag(DocTag.Param, documentationParameter.Name + " " + documentationParameter.Description);
}
}
result.Documentation = jsdoc;
}
var p = element.GetParameters();
foreach (var param in p)
{
if (Context.CurrentBlueprint.IsIgnored(param))
{
continue;
}
var generator = Context.Generators.GeneratorFor(param);
var argument = generator.Generate(param, resolver);
result.Arguments.Add((RtArgument)argument);
}
var bp = Context.Project.Blueprint(element.DeclaringType);
if (bp.ConstructorBody != null)
{
result.SuperCallParameters.Clear();
result.Body = bp.ConstructorBody;
}
else
{
SetupSuperCall(result, element, bp.ForMember(element));
}
return(result);
}
/// <summary>
/// Exports entire class to specified writer
/// </summary>
/// <param name="result">Exporting result</param>
/// <param name="type">Exporting class type</param>
/// <param name="resolver">Type resolver</param>
/// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param>
protected virtual void Export(ITypeMember result, Type type, TypeResolver resolver, IAutoexportSwitchAttribute swtch)
{
result.Name = type.GetName();
var doc = Context.Documentation.GetDocumentationMember(type);
if (doc != null)
{
RtJsdocNode docNode = new RtJsdocNode();
if (doc.HasSummary())
{
docNode.Description = doc.Summary.Text;
}
result.Documentation = docNode;
}
var ifaces = type.GetInterfaces();
var bs = type.BaseType;
var baseClassIsExportedAsInterface = false;
if (bs != null && bs != typeof(object))
{
if (ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(bs) != null)
{
if (bs.IsExportingAsInterface())
{
baseClassIsExportedAsInterface = true;
}
else
{
((RtClass)result).Extendee = resolver.ResolveTypeName(bs);
}
}
}
var implementees =
ifaces.Where(c => ConfigurationRepository.Instance.ForType <TsInterfaceAttribute>(c) != null)
.Select(resolver.ResolveTypeName).ToList();
if (baseClassIsExportedAsInterface)
{
implementees.Add(resolver.ResolveTypeName(bs));
}
result.Implementees.AddRange(implementees.OfType <RtSimpleTypeName>());
ExportMembers(type, resolver, result, swtch);
}
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtConstructor GenerateNode(ConstructorInfo element, RtConstructor result, TypeResolver resolver)
{
if (element.IsIgnored())
{
return(null);
}
if (element.GetParameters().Length == 0)
{
return(null);
}
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode jsdoc = new RtJsdocNode {
Description = doc.Summary.Text
};
foreach (var documentationParameter in doc.Parameters)
{
jsdoc.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Param,
documentationParameter.Name + " " + documentationParameter.Description));
}
result.Documentation = jsdoc;
}
var p = element.GetParameters();
foreach (var param in p)
{
if (param.IsIgnored())
{
continue;
}
var generator = Context.Generators.GeneratorFor(param, Context);
var argument = generator.Generate(param, resolver);
result.Arguments.Add((RtArgument)argument);
}
SetupSuperCall(result, element);
return(result);
}
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtField GenerateNode(MemberInfo element, RtField result, TypeResolver resolver)
{
if (Context.CurrentBlueprint.IsIgnored(element))
{
return(null);
}
result.IsStatic = element.IsStatic();
result.Order = Context.CurrentBlueprint.GetOrder(element);
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode jsdoc = new RtJsdocNode {
Description = doc.Summary.Text
};
result.Documentation = jsdoc;
}
var t = GetType(element);
RtTypeName type = null;
var propName = new RtIdentifier(element.Name);
bool isNameOverridden = false;
var tp = Context.CurrentBlueprint.ForMember <TsPropertyAttribute>(element);
if (tp != null)
{
if (tp.StrongType != null)
{
type = resolver.ResolveTypeName(tp.StrongType);
}
else if (!string.IsNullOrEmpty(tp.Type))
{
type = new RtSimpleTypeName(tp.Type);
}
type = tp.TypeInferers.Infer(element, resolver) ?? type;
if (!string.IsNullOrEmpty(tp.Name))
{
propName.IdentifierName = tp.Name;
isNameOverridden = true;
}
if (tp.NilForceNullable.HasValue && !Context.SpecialCase)
{
propName.IsNullable = tp.NilForceNullable.Value;
}
}
if (type == null)
{
type = resolver.ResolveTypeName(t);
}
if (tp != null && !tp.NilForceNullable.HasValue)
{
if (!propName.IsNullable && t.IsNullable() && !Context.SpecialCase)
{
propName.IsNullable = true;
}
}
if (!isNameOverridden)
{
if (element is PropertyInfo)
{
propName.IdentifierName =
Context.ConditionallyConvertPropertyNameToCamelCase(propName.IdentifierName);
}
propName.IdentifierName = Context.CurrentBlueprint.CamelCaseFromAttribute(element, propName.IdentifierName);
propName.IdentifierName = Context.CurrentBlueprint.PascalCaseFromAttribute(element, propName.IdentifierName);
}
if (this.Context.Location.CurrentClass != null)
{
this.FillInitialization(element, result, resolver, t, tp);
}
result.Identifier = propName;
result.AccessModifier = Context.SpecialCase ? AccessModifier.Public : element.GetModifier();
result.Type = type;
AddDecorators(result, Context.CurrentBlueprint.DecoratorsFor(element));
return(result);
}
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtEnum GenerateNode(Type element, RtEnum result, TypeResolver resolver)
{
Context.Location.SetCurrentType(element);
var names = Enum.GetNames(element);
var bp = Context.Project.Blueprint(element);
result.EnumName = bp.GetName();
result.Order = bp.GetOrder();
var fields = element._GetFields().Where(c => !c.IsSpecialName).ToDictionary(c => c.Name, c => c);
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode docNode = new RtJsdocNode();
if (doc.HasSummary())
{
docNode.Description = doc.Summary.Text;
}
result.Documentation = docNode;
}
bool stringInit = false;
var ea = Context.CurrentBlueprint.Attr <TsEnumAttribute>();
if (ea != null)
{
result.IsConst = ea.IsConst;
stringInit = ea.UseString;
}
List <RtEnumValue> valuesResult = new List <RtEnumValue>();
for (var index = 0; index < names.Length; index++)
{
var n = names.GetValue(index) as string;
var v = Enum.Parse(element, n);
if (fields.ContainsKey(n))
{
var fieldItself = fields[n];
var attr = Context.CurrentBlueprint.ForEnumValue(fieldItself);
if (attr != null)
{
n = attr.Name;
}
if (string.IsNullOrEmpty(n))
{
n = fieldItself.Name;
}
RtEnumValue value = new RtEnumValue
{
EnumValueName = n,
EnumValue = Convert.ToInt64(v).ToString()
};
if (stringInit)
{
if (attr != null && !string.IsNullOrEmpty(attr.Initializer))
{
value.EnumValue = String.Concat("\"", attr.Initializer, "\"");
}
else
{
value.EnumValue = String.Concat("\"", n, "\"");
}
}
var valueDoc = Context.Documentation.GetDocumentationMember(fieldItself);
if (valueDoc != null)
{
RtJsdocNode docNode = new RtJsdocNode();
if (valueDoc.HasSummary())
{
docNode.Description = valueDoc.Summary.Text;
}
value.Documentation = docNode;
}
valuesResult.Add(value);
}
}
result.Values.AddRange(valuesResult);
AddDecorators(result, Context.CurrentBlueprint.GetDecorators());
Context.Location.ResetCurrentType();
return(result);
}
public abstract void Visit(RtJsdocNode node);
public override void Visit(RtJsdocNode node)
{
}
/// <summary>
/// Exports entire class to specified writer
/// </summary>
/// <param name="result">Exporting result</param>
/// <param name="type">Exporting class type</param>
/// <param name="resolver">Type resolver</param>
/// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param>
protected virtual void Export(ITypeMember result, Type type, TypeResolver resolver, IAutoexportSwitchAttribute swtch)
{
var bp = Context.Project.Blueprint(type);
result.Name = bp.GetName();
result.Order = bp.GetOrder();
var doc = Context.Documentation.GetDocumentationMember(type);
if (doc != null)
{
RtJsdocNode docNode = new RtJsdocNode();
if (doc.HasSummary())
{
docNode.Description = doc.Summary.Text;
}
result.Documentation = docNode;
}
var materializedGenericParameters = type._GetGenericArguments()
.Where(c => c.GetCustomAttribute <TsGenericAttribute>() != null)
.ToDictionary(c => c.Name, resolver.ResolveTypeName);
if (materializedGenericParameters.Count == 0)
{
materializedGenericParameters = null;
}
if (!bp.IsFlatten())
{
var bs = type._BaseType();
var baseClassIsExportedAsInterface = false;
if (bs != null && bs != typeof(object))
{
bool baseAsInterface = false;
RtTypeName inferredBaseType = null;
if (bs._IsGenericType())
{
var genericBase = bs.GetGenericTypeDefinition();
var genericBaseBp = Context.Project.Blueprint(genericBase);
if (genericBaseBp.TypeAttribute != null || genericBaseBp.ThirdParty != null)
{
inferredBaseType = resolver.ResolveTypeName(bs,
MergeMaterializedGenerics(bs, resolver, materializedGenericParameters));
baseAsInterface = Context.Project.Blueprint(genericBase).IsExportingAsInterface();
}
}
if (inferredBaseType == null || !bs._IsGenericType())
{
var bsBp = Context.Project.Blueprint(bs);
if (bsBp.TypeAttribute != null || bsBp.ThirdParty != null)
{
baseAsInterface = Context.Project.Blueprint(bs).IsExportingAsInterface();
inferredBaseType = resolver.ResolveTypeName(bs,
MergeMaterializedGenerics(bs, resolver, materializedGenericParameters));
}
}
if (inferredBaseType != null)
{
if (baseAsInterface)
{
baseClassIsExportedAsInterface = true;
}
else
{
((RtClass)result).Extendee = inferredBaseType;
}
}
}
var implementees = ExtractImplementees(type, resolver, materializedGenericParameters).ToList();
if (baseClassIsExportedAsInterface)
{
implementees.Add(resolver.ResolveTypeName(bs, materializedGenericParameters));
}
result.Implementees.AddRange(implementees.OfType <RtSimpleTypeName>());
}
ExportMembers(type, resolver, result, swtch);
}
/// <summary>
/// Exports entire class to specified writer
/// </summary>
/// <param name="result">Exporting result</param>
/// <param name="type">Exporting class type</param>
/// <param name="resolver">Type resolver</param>
/// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param>
protected virtual void Export(ITypeMember result, Type type, TypeResolver resolver, IAutoexportSwitchAttribute swtch)
{
Context.Location.SetCurrentType(type);
result.Name = type.GetName();
result.Order = type.GetOrder();
var doc = Context.Documentation.GetDocumentationMember(type);
if (doc != null)
{
RtJsdocNode docNode = new RtJsdocNode();
if (doc.HasSummary())
{
docNode.Description = doc.Summary.Text;
}
result.Documentation = docNode;
}
var materializedGenericParameters = type.GetGenericArguments()
.Where(c => c.GetCustomAttribute <TsGenericAttribute>() != null)
.ToDictionary(c => c.Name, resolver.ResolveTypeName);
if (materializedGenericParameters.Count == 0)
{
materializedGenericParameters = null;
}
var bs = type.BaseType;
var baseClassIsExportedAsInterface = false;
if (bs != null && bs != typeof(object))
{
TsDeclarationAttributeBase attr = null;
bool baseAsInterface = false;
if (bs.IsGenericType)
{
var genericBase = bs.GetGenericTypeDefinition();
attr = ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(genericBase);
baseAsInterface = genericBase.IsExportingAsInterface();
}
else
{
attr = ConfigurationRepository.Instance.ForType <TsDeclarationAttributeBase>(bs);
baseAsInterface = bs.IsExportingAsInterface();
}
if (attr != null)
{
if (baseAsInterface)
{
baseClassIsExportedAsInterface = true;
}
else
{
((RtClass)result).Extendee = resolver.ResolveTypeName(bs, MergeMaterializedGenerics(bs, resolver, materializedGenericParameters));
}
}
}
var implementees = ExtractImplementees(type, resolver, materializedGenericParameters).ToList();
if (baseClassIsExportedAsInterface)
{
implementees.Add(resolver.ResolveTypeName(bs, materializedGenericParameters));
}
result.Implementees.AddRange(implementees.OfType <RtSimpleTypeName>());
ExportMembers(type, resolver, result, swtch);
Context.Location.ResetCurrentType();
}
public abstract T Visit(RtJsdocNode node);
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtFunction GenerateNode(MethodInfo element, RtFunction result, TypeResolver resolver)
{
if (Context.CurrentBlueprint.IsIgnored(element))
{
return(null);
}
string name;
RtTypeName type;
GetFunctionNameAndReturnType(element, resolver, out name, out type);
result.Identifier = new RtIdentifier(name);
result.ReturnType = type;
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode jsdoc = new RtJsdocNode();
if (doc.HasInheritDoc())
{
jsdoc.AddTag(DocTag.Inheritdoc);
}
if (doc.HasSummary())
{
jsdoc.Description = doc.Summary.Text;
}
if (doc.Parameters != null)
{
foreach (var documentationParameter in doc.Parameters)
{
jsdoc.AddTag(DocTag.Param, documentationParameter.Name + " " + documentationParameter.Description);
}
}
if (doc.HasReturns())
{
jsdoc.AddTag(DocTag.Returns, doc.Returns.Text);
}
result.Documentation = jsdoc;
}
result.Order = Context.CurrentBlueprint.GetOrder(element);
result.AccessModifier = element.GetModifier();
if (Context.SpecialCase)
{
result.AccessModifier = AccessModifier.Public;
}
result.Identifier = new RtIdentifier(name);
result.IsStatic = element.IsStatic;
var p = element.GetParameters();
foreach (var param in p)
{
if (Context.CurrentBlueprint.IsIgnored(param))
{
continue;
}
var generator = Context.Generators.GeneratorFor(param);
var argument = generator.Generate(param, resolver);
result.Arguments.Add((RtArgument)argument);
}
var fa = Context.CurrentBlueprint.ForMember(element);
if (fa != null && !string.IsNullOrEmpty(fa.Implementation))
{
result.Body = new RtRaw(fa.Implementation);
}
if (fa != null && fa.ForceAsync != null)
{
result.IsAsync = (bool)fa.ForceAsync;
}
else
{
if (Context.Global.AutoAsync)
{
result.IsAsync = element.IsAsync();
}
}
AddDecorators(result, Context.CurrentBlueprint.DecoratorsFor(element));
return(result);
}
/// <summary>
/// Main code generator method. This method should write corresponding TypeScript code for element (1st argument) to
/// WriterWrapper (3rd argument) using TypeResolver if necessary
/// </summary>
/// <param name="element">Element code to be generated to output</param>
/// <param name="result">Resulting node</param>
/// <param name="resolver">Type resolver</param>
public override RtField GenerateNode(MemberInfo element, RtField result, TypeResolver resolver)
{
if (element.IsIgnored())
{
return(null);
}
result.IsStatic = element.IsStatic();
var doc = Context.Documentation.GetDocumentationMember(element);
if (doc != null)
{
RtJsdocNode jsdoc = new RtJsdocNode {
Description = doc.Summary.Text
};
result.Documentation = jsdoc;
}
var t = GetType(element);
RtTypeName type = null;
var propName = new RtIdentifier(element.Name);
var tp = ConfigurationRepository.Instance.ForMember <TsPropertyAttribute>(element);
if (tp != null)
{
if (tp.StrongType != null)
{
type = resolver.ResolveTypeName(tp.StrongType);
}
else if (!string.IsNullOrEmpty(tp.Type))
{
type = new RtSimpleTypeName(tp.Type);
}
if (!string.IsNullOrEmpty(tp.Name))
{
propName.IdentifierName = tp.Name;
}
if (tp.ForceNullable && element.DeclaringType.IsExportingAsInterface() && !Context.SpecialCase)
{
propName.IsNullable = true;
}
}
if (type == null)
{
type = resolver.ResolveTypeName(t);
}
if (!propName.IsNullable && t.IsNullable() && element.DeclaringType.IsExportingAsInterface() &&
!Context.SpecialCase)
{
propName.IsNullable = true;
}
if (element is PropertyInfo)
{
propName.IdentifierName = Context.ConditionallyConvertPropertyNameToCamelCase(propName.IdentifierName);
}
propName.IdentifierName = element.CamelCaseFromAttribute(propName.IdentifierName);
propName.IdentifierName = element.PascalCaseFromAttribute(propName.IdentifierName);
result.Identifier = propName;
result.AccessModifier = Context.SpecialCase ? AccessModifier.Public : element.GetModifier();
result.Type = type;
return(result);
}
