/// <summary> /// Configures class to export constructor /// If constructor body is not specified, then default body will be generated. /// Default body is empty if there are no inheritance. /// If there is inheritance then RT will try to generate optimal super() call /// that can be controlled by <see cref="TsBaseParamAttribute"/> /// </summary> /// <typeparam name="T"></typeparam> /// <param name="conf"></param> /// <param name="exportConstructors">When true, constructor will be exported</param> /// <param name="constructorBody">Optional constructor body implementation</param> /// <returns></returns> public static T WithConstructor <T>(this T conf, RtRaw constructorBody = null, bool exportConstructors = true) where T : ClassExportBuilder { conf.Attr.AutoExportConstructors = exportConstructors; conf.Blueprint.ConstructorBody = constructorBody; return(conf); }
private void AddViewModelToNode(Type element, RtClass result) { var collectionName = new RtRaw($"static Name = '{result.Name.TypeName}';"); result.Members.Insert(0, collectionName); var initializationMethod = GenerateInitializationMethod(element, result); result.Members.Add(initializationMethod); }
private void CodeBlock(RtRaw content) { Br(); AppendTabs(); WriteLine("{"); Tab(); Visit(content); UnTab(); AppendTabs(); WriteLine("}"); }
public override void Visit(RtRaw node) { if (node == null) { return; } if (string.IsNullOrEmpty(node.RawContent)) { return; } WriteLines(node.RawContent); }
public override RtFuncion GenerateNode(MethodInfo element, RtFuncion 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 override RtClass GenerateNode(Type element, RtClass result, TypeResolver resolver) { result = base.GenerateNode(element, result, resolver); if (result == null) return null; // We add some docs to keep you oriented result.Documentation = new RtJsdocNode(){Description = "Result of AngularControllerGenerator activity"}; // Here we just create ng.IHttpService type name because it is used several times var httpServiceType = new RtSimpleTypeName("IHttpService") { Namespace = "angular" }; // Here we are declaring constructor for our angular service using $http as parameter // It is quite simple so no more details RtConstructor constructor = new RtConstructor(); constructor.Arguments.Add(new RtArgument(){Type = httpServiceType,Identifier = new RtIdentifier("$http")}); constructor.Body = new RtRaw("this.http = $http;"); // Here we declaring class field for storing $http instance RtField httpServiceField = new RtField() { Type = httpServiceType, Identifier = new RtIdentifier("http"), AccessModifier = AccessModifier.Private, Documentation = new RtJsdocNode() { Description = "Keeps $http instance received on construction"} }; // Here we are adding our constructor and field to resulting class result.Members.Add(httpServiceField); result.Members.Add(constructor); // Also we will add controller registration to our app instance // To automatically get it registered in Angular's IoC const string initializerFormat = "if (window['app']) window['app'].factory('Api.{0}', ['$http', ($http: angular.IHttpService) => new {1}($http)]);"; RtRaw registration = new RtRaw(String.Format(initializerFormat,element.Name,result.Name)); // Since RtModule.compilationUnits is not typed and could contain any type then we // simply add RtRaw node here with registration glue code // app variable is declared in /Scripts/ReinforcedTypings/App.ts since it is used in // corresponding client script Context.Location.CurrentModule.CompilationUnits.Add(registration); // That's all. here we return node that will be written to target file. // Check result in /Scripts/ReinforcedTypings/GeneratedTypings.ts return result; }
public override RtFuncion GenerateNode(MethodInfo element, RtFuncion 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; }
private RtRaw GenerateEnumDescription(Type element, RtEnum resultEnum) { var enumDescription = new StringBuilder(); enumDescription.AppendLine(); var enumName = resultEnum.EnumName; var tsType = $"{{[key in {enumName}]: {{long: string, short: string}}}}"; enumDescription.AppendLine($"export const {enumName}Descriptions: {tsType} = {{"); foreach (var resultEnumValue in resultEnum.Values) { var descriptionObj = GetElementDescription(element, resultEnumValue.EnumValueName); enumDescription.AppendLine($"\t[{enumName}.{resultEnumValue.EnumValueName}]: {descriptionObj},"); } enumDescription.AppendLine("};"); var item = new RtRaw(enumDescription.ToString()); return(item); }
public abstract void Visit(RtRaw node);
public override void Visit(RtRaw node) { }
public abstract T Visit(RtRaw node);
public override RtClass GenerateNode(Type element, RtClass result, TypeResolver resolver) { result = base.GenerateNode(element, result, resolver); if (result == null) { return(null); } // We add some docs to keep you oriented result.Documentation = new RtJsdocNode() { Description = "Result of AngularControllerGenerator activity" }; // Here we just create ng.IHttpService type name because it is used several times var httpServiceType = new RtSimpleTypeName("IHttpService") { Namespace = "angular" }; // Here we are declaring constructor for our angular service using $http as parameter // It is quite simple so no more details RtConstructor constructor = new RtConstructor(); constructor.Arguments.Add(new RtArgument() { Type = httpServiceType, Identifier = new RtIdentifier("$http") }); constructor.Body = new RtRaw("this.http = $http;"); // Here we declaring class field for storing $http instance RtField httpServiceField = new RtField() { Type = httpServiceType, Identifier = new RtIdentifier("http"), AccessModifier = AccessModifier.Private, Documentation = new RtJsdocNode() { Description = "Keeps $http instance received on construction" } }; // Here we are adding our constructor and field to resulting class result.Members.Add(httpServiceField); result.Members.Add(constructor); // Also we will add controller registration to our app instance // To automatically get it registered in Angular's IoC const string initializerFormat = "if (window['app']) window['app'].factory('Api.{0}', ['$http', ($http: angular.IHttpService) => new {1}($http)]);"; RtRaw registration = new RtRaw(String.Format(initializerFormat, element.Name, result.Name)); // Since RtModule.compilationUnits is not typed and could contain any type then we // simply add RtRaw node here with registration glue code // app variable is declared in /Scripts/ReinforcedTypings/App.ts since it is used in // corresponding client script Context.Location.CurrentModule.CompilationUnits.Add(registration); // That's all. here we return node that will be written to target file. // Check result in /Scripts/ReinforcedTypings/GeneratedTypings.ts return(result); }