public override void Visit(RtFunction node)
{
if (node == null)
{
return;
}
Visit(node.Documentation);
AppendTabs();
if (Context != WriterContext.Interface)
{
Modifiers(node);
}
if (Context == WriterContext.Module)
{
Write("export function ");
}
Visit(node.Identifier);
Write("(");
SequentialVisit(node.Arguments, ", ");
Write(") ");
if (node.ReturnType != null)
{
Write(": ");
Visit(node.ReturnType);
}
WriteLine(";");
if (!string.IsNullOrEmpty(node.LineAfter))
{
AppendTabs();
Write(node.LineAfter);
Br();
}
}
public override void Visit(RtFunction node)
{
if (node == null)
{
return;
}
Visit(node.Documentation);
AppendTabs();
if (Context != WriterContext.Interface)
{
Decorators(node);
Modifiers(node);
if (node.IsAsync)
{
Write("async ");
}
}
Visit(node.Identifier);
Write("(");
SequentialVisit(node.Arguments, ", ");
Write(") ");
if (node.ReturnType != null)
{
Write(": ");
if (node.IsAsync)
{
Write("Promise<");
}
Visit(node.ReturnType);
if (node.IsAsync)
{
Write(">");
}
}
if (Context == WriterContext.Interface)
{
WriteLine(";");
}
else
{
if (node.Body != null && !string.IsNullOrEmpty(node.Body.RawContent))
{
CodeBlock(node.Body);
}
else
{
EmptyBody(node.ReturnType);
}
}
if (!string.IsNullOrEmpty(node.LineAfter))
{
AppendTabs();
Write(node.LineAfter);
Br();
}
}
public override void Visit(RtFunction node)
{
var reflectionAttachedRtFunction = node as ReflectionAttachedRtFunction;
if (reflectionAttachedRtFunction != null && !reflectionAttachedRtFunction.Handled)
{
reflectionAttachedRtFunction.Handled = true;
ReflectionFunction(reflectionAttachedRtFunction);
}
}
/// <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)
{
var b = base.GenerateNode(element, result, resolver);
if (b == null)
{
return(null);
}
result.Identifier.IdentifierName = result.Identifier.IdentifierName + "1";
return(b);
}
public override RtFunction GenerateNode(MethodInfo element, RtFunction result, TypeResolver resolver)
{
result = base.GenerateNode(element, result, resolver);
if (result == null)
{
return(null);
}
// here we are overriding return type to corresponding promise
var retType = result.ReturnType;
bool isVoid = (retType is RtSimpleTypeName) && (((RtSimpleTypeName)retType).TypeName == "void");
// we use TypeResolver to get "any" type to avoid redundant type name construction
// (or because I'm too lazy to manually construct "any" type)
if (isVoid)
{
retType = resolver.ResolveTypeName(typeof(object));
}
// Here we override TS method return type to make it angular.IPromise
// We are using RtSimpleType with generig parameter of existing method type
result.ReturnType = new RtSimpleTypeName(new[] { retType }, "angular", "IPromise");
// Here we retrieve method parameters
// We are using .GetName() extension method to retrieve parameter name
// It is supplied within Reinforced.Typings and retrieves parameter name
// including possible name override with Fluent configuration or
// [TsParameter] attribute
var p = element.GetParameters().Select(c => string.Format("'{0}': {0}", c.GetName()));
// Joining parameters for method body code
var dataParameters = string.Join(", ", p);
// Here we get path to controller
// It is quite simple solution requiring /{controller}/{action} route
string controller = element.DeclaringType.Name.Replace("Controller", String.Empty);
string path = String.Format("/{0}/{1}", controller, element.Name);
const string code = @"var params = {{ {1} }};
return this.http.post('{0}', params)
.then((response) => {{ response.data['requestParams'] = params; return response.data; }});";
RtRaw body = new RtRaw(String.Format(code, path, dataParameters));
result.Body = body;
// That's all. here we return node that will be written to target file.
// Check result in /Scripts/ReinforcedTypings/GeneratedTypings.ts
return(result);
}
public ReflectionAttachedRtFunction(RtFunction actual, MethodInfo methodInfo)
{
MethodInfo = methodInfo;
this.IsAsync = actual.IsAsync;
this.Identifier = actual.Identifier;
this.ReturnType = actual.ReturnType;
foreach (var argument in actual.Arguments)
{
Arguments.Add(argument);
}
foreach (var decorator in actual.Decorators)
{
Decorators.Add(decorator);
}
this.Body = actual.Body;
this.CopyActualProperties(actual);
}
private RtDelegateType GetCallbackType(RtFunction function)
{
return(new RtDelegateType(function.Arguments.ToArray(), new RtSimpleTypeName("void")));
}
public abstract void Visit(RtFunction node);
public abstract T Visit(RtFunction node);
/// <summary>
/// We override GenerateNode method (since it is almost single method of code generator).
/// </summary>
/// <param name="element">Method of controller that we generate code for</param>
/// <param name="result">
/// Resulting node - we do not have to create resulting node by ourselfs.
/// But wi still can return null from GenerateNode method
/// </param>
/// <param name="resolver">
/// TypeResolver object that we will use to safely convert CLR types to TypeScript types names
/// </param>
/// <returns>AST node for method declaration</returns>
public override RtFunction GenerateNode(MethodInfo element, RtFunction result, TypeResolver resolver)
{
// Here we get default result of method export
result = base.GenerateNode(element, result, resolver);
if (result == null)
{
return(null);
}
// We make method static since we will call it like JQueryController.Method
result.IsStatic = true;
// Below we will add special arguments for specifying element that should be
// disabled during query (disable element) and element placeholder for
// loading inidicator
result.Arguments.Add(
new RtArgument()
{
Identifier = new RtIdentifier("loadingPlaceholderSelector"),
Type = resolver.ResolveTypeName(typeof(string)),
DefaultValue = "''"
});
result.Arguments.Add(
new RtArgument()
{
Identifier = new RtIdentifier("disableElement"),
Type = resolver.ResolveTypeName(typeof(string)),
DefaultValue = "''"
});
// We save original type name
var retType = result.ReturnType;
// ... and in case of void we just replace it with "any"
bool isVoid = (retType is RtSimpleTypeName) && (((RtSimpleTypeName)retType).TypeName == "void");
// we use TypeResolver to get "any" type to avoid redundant type name construction
// (or because I'm too lazy to manually construct "any" type)
if (isVoid)
{
retType = resolver.ResolveTypeName(typeof(object));
}
// Here we override TS method return type to make it JQueryPromise
// We are using RtSimpleType with generig parameter of existing method type
result.ReturnType = new RtSimpleTypeName("JQueryPromise", new[] { retType });
// Here we retrieve method parameters
// We are using .GetName() extension method to retrieve parameter name
// It is supplied within Reinforced.Typings and retrieves parameter name
// including possible name override with Fluent configuration or
// [TsParameter] attribute
var p = element.GetParameters().Select(c => string.Format("'{0}': {0}", c.GetName()));
// Joining parameters for method body code
var dataParameters = string.Join(", ", p);
// Here we get path to controller
// It is quite simple solution requiring /{controller}/{action} route
string controller = element.DeclaringType.Name.Replace("Controller", String.Empty);
string path = String.Format("/{0}/{1}", controller, element.Name);
// Here we are constructing our glue code
// Please refer to /Scripts/ReinforcedTypings/query.ts for implementation of QueryController.query method
string code = String.Format(
@"return QueryController.query<{2}>(
'{0}',
{{ {1} }},
loadingPlaceholderSelector,
disableElement
);",
path, dataParameters, retType);
// Here we just set method body and return method node
result.Body = new RtRaw(code);
// Also here we will add some JSDOC
result.Documentation = new RtJsdocNode()
{
Description = String.Format("Wrapper method for call {0} of {1}", element.Name, element.DeclaringType.Name)
};
// That's all. here we return node that will be written to target file.
// Check result in /Scripts/ReinforcedTypings/GeneratedTypings.ts
return(result);
}
