private static void GenerateScript( StringBuilder output, string template, CodeGeneratorParameters parameters) { StringBuilder methodOutput = new StringBuilder(1024); int lineNumber = 1; GenerateMethodBody( methodOutput, template, parameters, 0, template.Length - 1, ref lineNumber); output.AppendLine($@"class ScriptTemplate : TemplateBase<{parameters.TemplateContextType.FullName}> {{"); output.AppendLine($"\tpublic ScriptTemplate(TextWriter output, {parameters.TemplateContextType.FullName} context) : base(output, context) {{ }}"); foreach (var property in GetTypeProperties(parameters.TemplateContextType)) { output.Append($"\tprivate {GetTypeString(property.PropertyType)} {property.Name} {{ get => _Context.{property.Name}; "); if (property.SetMethod?.IsPublic ?? false) { output.Append($"set => _Context.{property.Name} = value; "); } output.AppendLine("}"); } foreach (var method in GetTypeMethods(parameters.TemplateContextType)) { var methodParams = method.GetParameters(); var methodParamsDeclaration = string.Join(", ", method.GetParameters().Select(x => $"{GetTypeString(x.ParameterType)} {x.Name}")); var methodParamsList = string.Join(", ", method.GetParameters().Select(x => x.Name)); if (!method.IsStatic) { output.AppendLine($"\tprivate {GetTypeString(method.ReturnType)} {method.Name}({methodParamsDeclaration}) => _Context.{method.Name}({methodParamsList});"); } else { output.AppendLine($"\tprivate static {GetTypeString(method.ReturnType)} {method.Name}({methodParamsDeclaration}) => {GetTypeString(method.DeclaringType)}.{method.Name}({methodParamsList});"); } } output.AppendLine("\tpublic void _Run() {"); output.Append(methodOutput.ToString()); output.AppendLine("\t}"); output.AppendLine("}"); output.AppendLine(); output.AppendLine($"return new Action<TextWriter, {parameters.TemplateContextType.FullName}>((output, context) => {{"); output.AppendLine("\tvar template = new ScriptTemplate(output, context);"); output.AppendLine("\ttemplate._Run();"); output.AppendLine("});"); }
private static void FlushBuffer( CodeGeneratorParameters parameters, BufferContents contents, StringBuilder buffer, StringBuilder output, int lineNumber) { if (parameters.IncludeLineDirectives) { output.AppendLine($"#line {lineNumber}"); } if (buffer.Length > 0) { switch (contents) { case BufferContents.Literal: string literal = buffer.ToString().Replace("\"", "\"\""); output.AppendLine($"_WriteLiteral(@\"{literal}\");"); break; case BufferContents.Expression: output.AppendLine($"_Write({buffer.ToString()});"); break; } buffer.Clear(); } }
private static void ParseCodeBlock( string template, CodeGeneratorParameters parameters, ref int i, ref int lineNumber, StringBuilder output) { if (parameters.IncludeLineDirectives) { output.AppendLine($"#line {lineNumber}"); } int closeCurlyBrace = FindClosingCurlyBrace(template, i); if (closeCurlyBrace == -1) { throw new TextDecoratorDotNetException("Matching } not found while parsing code block."); } int startCode = i + 1; int endCode = closeCurlyBrace - 1; if (startCode < endCode) { AppendLine(output, template, startCode, endCode); } i = closeCurlyBrace + 1; }
public void Construct() { var buildSystem = new FakeBuildSystem(); var codeNamespace = new CodeNamespace(_sampleNamespace); ICodeGeneratorParameters configuration = new CodeGeneratorParameters(_outputDirectory); var testBuilders = MemberBuilderFactory.Default; Assert.Throws <ArgumentNullException>(() => new CSharpCodeGenerator(null, codeNamespace, testBuilders, configuration)); Assert.Throws <ArgumentNullException>(() => new CSharpCodeGenerator(buildSystem, null, testBuilders, configuration)); new CSharpCodeGenerator(buildSystem, codeNamespace, null, configuration); Assert.Throws <ArgumentException>(() => new CSharpCodeGenerator(buildSystem, codeNamespace, testBuilders, null)); configuration = MockRepository.GenerateStub <ICodeGeneratorParameters>(); configuration.Expect((e) => e.OutputDirectory).Return(null); Assert.Throws <ArgumentNullException>(() => new CSharpCodeGenerator(buildSystem, codeNamespace, testBuilders, configuration)); configuration.Expect((e) => e.OutputDirectory).Return(string.Empty); Assert.Throws <ArgumentException>(() => new CSharpCodeGenerator(buildSystem, codeNamespace, testBuilders, configuration)); configuration = new CodeGeneratorParameters(_outputDirectory); buildSystem = new FakeBuildSystem() { FakeDirectoryExists = false }; Assert.Throws <ApplicationException>(() => new CSharpCodeGenerator(buildSystem, codeNamespace, testBuilders, configuration)); }
public void ConstructWithParametersOutputDirectoryTest() { this.outputDirectory = "Value of outputDirectory"; this.testObject = new CodeGeneratorParameters(this.outputDirectory); Assert.Throws <ArgumentException>(() => new CodeGeneratorParameters(string.Empty)); Assert.Throws <ArgumentNullException>(() => new CodeGeneratorParameters(null)); }
private void BtnGoClick(object sender, EventArgs e) { Dumper(); string outputFolder = this._outputDirectoryTextBox.Text; var para = new CodeGeneratorParameters(outputFolder) { MethodGeneratorLevelOfDetail = MemberVisibility.Internal }; // bg.CustomGeneratorParameters = para; /*var bg = new LoadAssemblyWorker(sbs, this.buildData, this) * { * BrowseInputAssemblyButton = this._browseInputAssemblyButton, * BrowseOutputDirectoryButton = this._browseOutputDirectoryButton, * GoButton = this._goButton, * Logger = Log, * };*/ Type generatorType = (Type)cbGenerators.SelectedItem; string inputAssemblyPath = this._inputAssemblyTextBox.Text; IList <TreeNode> mainNodes = this._assemblyGraphTreeView.Nodes.Cast <TreeNode>().ToList(); IList <AssemblyName> referencedAssemblies = this._referencedAssemblies; //var data = new GeneratorRunnerData(outputFolder, generatorType, inputAssemblyPath, mainNodes.MapToNodes(), referencedAssemblies); var data = GeneratorRunnerData.Create(outputFolder, generatorType, inputAssemblyPath, mainNodes.MapToNodes(), referencedAssemblies); bg.RunWorkerAsync(data, para); }
public void SetUp() { var codeNamespace = new CodeNamespace(_sampleNamespace); var configuration = new CodeGeneratorParameters(_outputDirectory); // Todo: Mock this. var testBuilders = MemberBuilderFactory.Default; var buildSystem = new FakeBuildSystem(); _cSharpCodeGenerator = new CSharpCodeGenerator(buildSystem, codeNamespace, testBuilders, configuration); }
private static void ParseExpression( string template, CodeGeneratorParameters parameters, ref int i, ref int lineNumber, StringBuilder buffer, StringBuilder output) { bool finished = false; while (!finished) { if (!char.IsLetterOrDigit(template[i])) { finished = true; if (template[i] == '.') { buffer.Append(template[i]); i++; finished = false; } else if (template[i] == '(') { ParseExpressionBlock(template, ref i, buffer, '(', ')'); finished = false; } else if (template[i] == '[') { ParseExpressionBlock(template, ref i, buffer, '[', ']'); finished = false; } } else { buffer.Append(template[i]); i++; } if (i >= template.Length) { finished = true; } } FlushBuffer( parameters, BufferContents.Expression, buffer, output, lineNumber); }
public CodeGeneratorResult Generate(string template, CodeGeneratorParameters parameters) { if (template == null) throw new ArgumentNullException("template"); StringBuilder output = new StringBuilder(); CodeGeneratorResult result = new CodeGeneratorResult(); GenerateClass(output, template, parameters, result); result.Code = output.ToString(); return result; }
public static string Generate(string template, CodeGeneratorParameters parameters) { if (template == null) { throw new ArgumentNullException(nameof(template)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } StringBuilder output = new StringBuilder(1024); GenerateScript(output, template, parameters); return(output.ToString()); }
static void Main(string[] args) { string templateSource = @"@using System.Diagnostics @property int Count @property string Name <html> <head> </head> <body> @for (int i = 0; i < Count; i++) { <p>Hello @Name!</p> } </body> </html>"; CodeGenerator codeGenerator = new CodeGenerator(); var codeGeneratorParameters = new CodeGeneratorParameters(); codeGeneratorParameters.ClassName = "Foo"; var codeGeneratorResult = codeGenerator.Generate(templateSource, codeGeneratorParameters); //Console.WriteLine(codeGeneratorResult.Code); Compiler compiler = new Compiler(); var compilerParameters = new CompilerParameters(); var template = compiler.CompileTemplate(templateSource, compilerParameters); template.SetPropertyValue("Count", 20); template.SetPropertyValue("Name", "Bob Freeman"); Console.WriteLine(template.Run()); Console.WriteLine("Press any key to continue..."); Console.ReadKey(); }
private static void ParseLogicBlock( string type, string template, CodeGeneratorParameters parameters, ref int i, ref int lineNumber, StringBuilder output) { if (parameters.IncludeLineDirectives) { output.AppendLine($"#line {lineNumber}"); } int openParen = FindNext(template, i, "("); if (openParen == -1) { throw new TextDecoratorDotNetException(string.Format("Expected ( while parsing {0}.", type)); } int closeParen = FindClosingParen(template, openParen); if (closeParen == -1) { throw new TextDecoratorDotNetException(string.Format("Matching ) not found while parsing {0}.", type)); } int openCurlyBrace = FindNext(template, closeParen, "{"); if (openCurlyBrace == -1) { throw new TextDecoratorDotNetException(string.Format("Expected {{ while parsing {0}.", type)); } int closeCurlyBrace = FindClosingCurlyBrace(template, openCurlyBrace); if (closeCurlyBrace == -1) { throw new TextDecoratorDotNetException(string.Format("Matching }} not found while parsing {0}.", type)); } output.Append(' '); // Append a single space to compensate for the @ sign. AppendLine(output, template, i, openCurlyBrace); int startCode = openCurlyBrace + 1; int endCode = closeCurlyBrace - 1; while (startCode < template.Length && LookAhead(template, startCode, Environment.NewLine)) { startCode += Environment.NewLine.Length; lineNumber++; } if (startCode < endCode) { GenerateMethodBody( output, template, parameters, startCode, endCode, ref lineNumber); } output.AppendLine("}"); i = closeCurlyBrace + 1; }
public void SetUp() { this.outputDirectory = "Value of outputDirectory"; this.testObject = new CodeGeneratorParameters(this.outputDirectory); }
private static void GenerateClass(StringBuilder output, string template, CodeGeneratorParameters parameters, CodeGeneratorResult result) { StringBuilder methodOutput = new StringBuilder(); GenerateMethodBody(methodOutput, template, 0, template.Length - 1, result); output.AppendLine("using System;"); foreach (var usingString in result.Usings) output.AppendLine("using {0};", usingString); output.AppendLine(); output.AppendLine("namespace Machete.Templates"); output.AppendLine("{"); output.AppendLine("\tpublic class {0} : {1}", parameters.ClassName, parameters.BaseClassName); output.AppendLine("\t{"); foreach (var propertyString in result.Properties) output.AppendLine("\t\tpublic {0} {{ get; set; }}", propertyString); output.AppendLine(); output.AppendLine("\t\tprotected override void Execute()"); output.AppendLine("\t\t{"); output.Append(methodOutput); output.AppendLine("\t\t}"); output.AppendLine("\t}"); output.AppendLine("}"); }
public void TearDown() { this.testObject = null; }
public void GenerateWithAssemblyAndModuleAndClassesAndMethod() { //expected = false; var outputFolder = "Value ? of ou$tputFol*der"; var generatorType = typeof(object); var inputAssemblyPath = "Value of inputAssemblyPath"; char directorySeparator = '\\'; var firstModuleName = "TheTestNode"; var firstModuleTag = "FirstModule"; var className1Namespace = "The.Namespace"; var className1 = "VeryPrettyFactory"; var className1FullName = className1Namespace + "." + className1; var classTag = this.GetType(); var methodName = "MyMethod"; var methodTag = this.GetType().GetMethod("FakeMethod"); var assemblyNode = new TestNode(firstModuleName + ".dll", TestNodeType.Assembly, null) { Checked = true }; var moduleNode = new TestNode(firstModuleName + ".dll", TestNodeType.Module, firstModuleTag) { Checked = true }; var classNode = new TestNode(className1FullName, TestNodeType.Class, classTag) { Checked = true }; var methodNode = new TestNode(methodName, TestNodeType.Method, methodTag) { Checked = true }; assemblyNode.Nodes.Add(moduleNode); moduleNode.Nodes.Add(classNode); classNode.Nodes.Add(methodNode); var mainNodes = new[] { assemblyNode }; var referencedAssemblies = typeof(CSharpTestProjectBuilderTest).Assembly.GetReferencedAssemblies(); var para = new CodeGeneratorParameters(outputFolder); var runnerData = GeneratorRunnerData.Create( outputFolder, generatorType, inputAssemblyPath, mainNodes, referencedAssemblies); Expect.Call(sbs.DirectorySeparatorChar).Return(directorySeparator).Repeat.Any(); Expect.Call(sbs.GetFileNameWithoutExtension(firstModuleName + ".dll")).Return(firstModuleName); var expectedDirectory = outputFolder + directorySeparator + firstModuleName + ".Tests"; Expect.Call(sbs.CreateDirectory(expectedDirectory)).Return(null); Expect.Call(sbs.DirectoryExists(expectedDirectory)).Return(true); var prjReferencedAssemblies = new List <AssemblyName>(); Expect.Call(projectGenerator.ReferencedAssemblies).Return(prjReferencedAssemblies).Repeat.Any(); Expect.Call(projectGenerator.GenerateProjectFile).Repeat.Once(); var classFilesList = new List <string>(); Expect.Call(projectGenerator.ClassFiles).Return(classFilesList).Repeat.Once(); var codeGenerator = mocks.StrictMock <ICodeGenerator>(); CodeNamespace generatorCodeNamespace = null; IBuildDataDictionary generatorBuildData = null; Expect.Call(createGeneratorCallback(sbs, null, null, null)) //.Constraints(Is.Same(sbs), Is.TypeOf<CodeGeneratorParameters>(), Is.TypeOf<CodeNamespace>()) .Constraints( Is.Same(sbs), Is.TypeOf <IBuildDataDictionary>() && Is.NotNull(), Is.TypeOf <CodeGeneratorParameters>() && Property.Value("OutputDirectory", expectedDirectory), Is.TypeOf <CodeNamespace>()) //.Return(codeGenerator) .Do((Func <IBuildSystem, IBuildDataDictionary, ICodeGeneratorParameters, CodeNamespace, ICodeGenerator>) delegate(IBuildSystem buildSys, IBuildDataDictionary data, ICodeGeneratorParameters cgp, CodeNamespace cn) { Assert.AreEqual(expectedDirectory, cgp.OutputDirectory); Assert.IsFalse(cgp.UseSetupAndTearDown); generatorBuildData = data; generatorCodeNamespace = cn; return(codeGenerator); }); Expect.Call(codeGenerator.CodeNamespace = null).PropertyBehavior(); Expect.Call(codeGenerator.OutputDirectory = expectedDirectory); Expect.Call(codeGenerator.GenerateCode); // logging Expect.Call(delegate { this.logger(null); }).Constraints(Is.NotNull()).Repeat.AtLeastOnce(); Expect.Call(projectGenerator.ProjectName).Return(firstModuleName).Repeat.Any(); mocks.ReplayAll(); testObject.GenerateTests(runnerData); //Assert.AreEqual(expected, actual); Assert.IsNotEmpty(generatorBuildData); Assert.Count(1, generatorBuildData); Assert.IsTrue(generatorBuildData.Contains(this.buildDataItem)); Assert.IsNotEmpty(prjReferencedAssemblies); Assert.IsNotEmpty(classFilesList); Assert.IsEmpty(generatorCodeNamespace.Comments); Assert.IsEmpty(generatorCodeNamespace.Imports); Assert.AreEqual(className1Namespace, generatorCodeNamespace.Name); Assert.IsNotEmpty(generatorCodeNamespace.Types); Assert.IsEmpty(generatorCodeNamespace.UserData); var classDefinition1 = generatorCodeNamespace.Types[0]; Assert.AreEqual(MemberAttributes.Private | MemberAttributes.Final, classDefinition1.Attributes); Assert.IsEmpty(classDefinition1.BaseTypes); Assert.IsEmpty(classDefinition1.Comments); Assert.IsEmpty(classDefinition1.CustomAttributes); Assert.AreEqual(className1FullName, classDefinition1.Name); Assert.IsTrue(classDefinition1.IsClass); Assert.IsEmpty(classDefinition1.StartDirectives); Assert.IsEmpty(classDefinition1.TypeParameters); Assert.IsNotEmpty(classDefinition1.UserData); Assert.Count(1, classDefinition1.UserData); Assert.AreEqual(classTag, classDefinition1.UserData[NStubConstants.UserDataClassTypeKey]); Assert.IsNotEmpty(classDefinition1.Members); var class1Members = classDefinition1.Members; // Todo: More checks on the generated types. mocks.VerifyAll(); }
/// <summary> /// Generates the edit page. /// </summary> /// <param name="entityName">Name of the entity.</param> /// <param name="generateContentPlaceholder">if set to <c>true</c> [generate content placeholder].</param> /// <param name="columns">The columns.</param> /// <param name="namespaceName">Name of the namespace.</param> /// <param name="outputPath">The output path.</param> /// <param name="relations">The relations.</param> private void GenerateEditPage(string entityName, bool generateContentPlaceholder, DatabaseColumn[] columns, string namespaceName, string outputPath, List <TableRelation> relations) { #region generate edit page FileStream fileStreamEditPage = null; StreamWriter writeEditPage = null; FileStream fileStreamEditCodeBehind = null; StreamWriter writerEditCodeBehind = null; FileStream fileStreamEditControldCodeBehind = null; StreamWriter writerControlsCodeBehind = null; Dictionary <string, string> dict = null; FileStream fileStreamPresenter = null; StreamWriter writerPresenter = null; try { parameters = new CodeGeneratorParameters(); parameters.Columns = columns; parameters.EntityName = entityName; parameters.GenerateContentPlaceholder = generateContentPlaceholder; parameters.NamespaceName = namespaceName; parameters.OutputPath = outputPath; parameters.Relations = relations; fileStreamEditPage = new FileStream(outputPath + @"\" + entityName + "Edit.aspx", this.GetStreamOpenMode(outputPath + @"\" + entityName + "Edit.aspx")); writeEditPage = new StreamWriter(fileStreamEditPage); dict = new Dictionary <string, string>(); this.WriteEditPageHeader(writeEditPage); this.WriteEditPageContent(writeEditPage, out dict); this.WriteEditPageFooter(writeEditPage); //write edit page code behind writeEditPage.Flush(); fileStreamEditCodeBehind = new FileStream(outputPath + @"\" + entityName + "Edit.aspx.cs", this.GetStreamOpenMode(outputPath + @"\" + entityName + "Edit.aspx.cs")); writerEditCodeBehind = new StreamWriter(fileStreamEditCodeBehind); this.WriteEditPageCodeBehind(writerEditCodeBehind); writerEditCodeBehind.Flush(); fileStreamEditControldCodeBehind = new FileStream(outputPath + @"\" + entityName + "Edit.aspx.designer.cs", this.GetStreamOpenMode(outputPath + @"\" + entityName + "Edit.aspx.designer.cs")); writerControlsCodeBehind = new StreamWriter(fileStreamEditControldCodeBehind); this.WriteEditPageDesignerCode(writerControlsCodeBehind, dict); writerControlsCodeBehind.Flush(); fileStreamPresenter = new FileStream(outputPath + @"\" + entityName + "EditPresenter.cs", this.GetStreamOpenMode(outputPath + @"\" + entityName + "Presenter.cs")); writerPresenter = new StreamWriter(fileStreamPresenter); this.WriteEditPagePresenter(writerPresenter); writerPresenter.Flush(); } finally { if (fileStreamEditPage != null) { fileStreamEditPage.Close(); } if (fileStreamEditCodeBehind != null) { fileStreamEditCodeBehind.Close(); } if (fileStreamEditControldCodeBehind != null) { fileStreamEditControldCodeBehind.Close(); } if (fileStreamPresenter != null) { fileStreamPresenter.Close(); } } #endregion }
private static void GenerateMethodBody( StringBuilder output, string template, CodeGeneratorParameters parameters, int start, int end, ref int lineNumber) { StringBuilder buffer = new StringBuilder(1024); int i = start; while (i <= end) { if (template[i] == '@') { if (LookAhead(template, i, "@@")) { buffer.Append("@"); i += 2; continue; } if (buffer.Length != 0) { string bufferContents = buffer.ToString(); FlushBuffer( parameters, BufferContents.Literal, buffer, output, lineNumber); lineNumber += CountOccurences(bufferContents, 0, bufferContents.Length, Environment.NewLine); } i++; int beforePos = i; if (LookAhead(template, i, "(")) { ParseExpressionBlock(template, ref i, buffer, '(', ')'); FlushBuffer( parameters, BufferContents.Expression, buffer, output, lineNumber); } else if (LookAhead(template, i, "{")) { ParseCodeBlock(template, parameters, ref i, ref lineNumber, output); } else if (LookAhead(template, i, "for")) { ParseLogicBlock("for", template, parameters, ref i, ref lineNumber, output); } else if (LookAhead(template, i, "foreach")) { ParseLogicBlock("foreach", template, parameters, ref i, ref lineNumber, output); } else if (LookAhead(template, i, "if")) { ParseLogicBlock("if", template, parameters, ref i, ref lineNumber, output); } else if (LookAhead(template, i, "while")) { ParseLogicBlock("while", template, parameters, ref i, ref lineNumber, output); } else { ParseExpression(template, parameters, ref i, ref lineNumber, buffer, output); } lineNumber += CountOccurences(template, beforePos, i, Environment.NewLine); } else { buffer.Append(template[i]); i++; } } FlushBuffer( parameters, BufferContents.Literal, buffer, output, lineNumber); }