|
public GenerateCodeFromNamespace ( CodeNamespace codeNamespace, |
||
| codeNamespace | CodeNamespace | |
| writer | ||
| options | ||
| return | void | |
public void GenerateTestFile(SpecFlowFeatureFile featureFile, CodeDomProvider codeProvider, TextReader inputReader, TextWriter outputWriter)
{
outputWriter = new HackedWriter(outputWriter);
var codeNamespace = GenerateTestFileCode(featureFile, inputReader);
var options = new CodeGeneratorOptions
{
BracingStyle = "C"
};
AddSpecFlowHeader(codeProvider, outputWriter);
codeProvider.GenerateCodeFromNamespace(codeNamespace, outputWriter, options);
outputWriter.Flush();
}
public void GenerateTestFile(FeatureFileInput featureFile, CodeDomProvider codeProvider, TextReader inputReader, TextWriter outputWriter)
{
outputWriter = new IndentProcessingWriter(outputWriter);
CodeDomHelper codeDomHelper = new CodeDomHelper(codeProvider);
var codeNamespace = GenerateTestFileCode(featureFile, inputReader, codeProvider, codeDomHelper);
var options = new CodeGeneratorOptions
{
BracingStyle = "C"
};
AddSpecFlowHeader(codeProvider, outputWriter, codeDomHelper);
codeProvider.GenerateCodeFromNamespace(codeNamespace, outputWriter, options);
AddSpecFlowFooter(codeProvider, outputWriter, codeDomHelper);
outputWriter.Flush();
}
private void GenerateTestCase(CodeDomProvider provider, string extension, string ns, string name, string area,
string[] actions, TextWriter output)
{
CodeNamespace nsunit = GenerateControllerTestCode(ns, name, area, actions);
FileInfo controllerFile = new FileInfo(
Path.Combine(testsDir.FullName, name + "Tests" + extension) );
if (!controllerFile.Exists)
{
using (StreamWriter sw = new StreamWriter(controllerFile.FullName, false, Encoding.Default))
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
opts.BracingStyle = "C";
#if DOTNET2
provider.GenerateCodeFromNamespace(nsunit, sw, opts);
#else
provider.CreateGenerator().GenerateCodeFromNamespace(nsunit, sw, opts);
#endif
}
}
else
{
output.WriteLine("Skipping {0} as the files exists", controllerFile.FullName);
}
}
private static String ConstructGeneratorCode(TemplateItem item, Boolean lineNumbers, String namespaceName, CodeDomProvider provider)
{
// 准备类名和命名空间
CodeNamespace codeNamespace = new CodeNamespace(namespaceName);
// 加入引用的命名空间
foreach (String str in item.Imports)
{
if (!String.IsNullOrEmpty(str)) codeNamespace.Imports.Add(new CodeNamespaceImport(str));
}
CodeTypeDeclaration typeDec = new CodeTypeDeclaration(item.ClassName);
typeDec.IsClass = true;
codeNamespace.Types.Add(typeDec);
// 基类
if (!String.IsNullOrEmpty(item.BaseClassName))
typeDec.BaseTypes.Add(new CodeTypeReference(item.BaseClassName));
else if (!String.IsNullOrEmpty(BaseClassName))
typeDec.BaseTypes.Add(new CodeTypeReference(BaseClassName));
else
typeDec.BaseTypes.Add(new CodeTypeReference(typeof(TemplateBase)));
if (!String.IsNullOrEmpty(item.Name)) typeDec.LinePragma = new CodeLinePragma(item.Name, 1);
// Render方法
CreateRenderMethod(item.Blocks, lineNumbers, typeDec);
// 代码生成选项
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.VerbatimOrder = true;
options.BlankLinesBetweenMembers = false;
options.BracingStyle = "C";
// 其它类成员代码块
Boolean firstMemberFound = false;
foreach (Block block in item.Blocks)
{
firstMemberFound = GenerateMemberForBlock(block, typeDec, lineNumbers, provider, options, firstMemberFound);
}
// 模版变量
if (item.Vars != null && item.Vars.Count > 0)
{
// 构建静态构造函数，初始化静态属性Vars
CreateCctorMethod(typeDec, item.Vars);
//public Int32 VarName
//{
// get { return (Int32)GetData("VarName"); }
// set { Data["VarName"] = value; }
//}
foreach (String v in item.Vars.Keys)
{
TypeX vtype = TypeX.Create(item.Vars[v]);
String codeName = vtype.FullName;
StringBuilder sb = new StringBuilder();
sb.AppendLine();
sb.AppendFormat("public {0} {1}", codeName, v);
sb.AppendLine("{");
sb.AppendFormat(" get {{ return GetData<{0}>(\"{1}\"); }}", codeName, v);
sb.AppendLine();
sb.AppendFormat(" set {{ Data[\"{0}\"] = value; }}", v);
sb.AppendLine();
sb.AppendLine("}");
CodeSnippetTypeMember member = new CodeSnippetTypeMember(sb.ToString());
typeDec.Members.Add(member);
}
}
// 输出
using (StringWriter writer = new StringWriter())
{
provider.GenerateCodeFromNamespace(codeNamespace, new IndentedTextWriter(writer), options);
return writer.ToString();
}
}
/// <summary>
/// Generates source code from given namespace.
/// </summary>
private static string GenerateFromNamespace(CodeDomProvider codeProvider, System.CodeDom.CodeNamespace codeNamespace, bool blankLinesBetweenMembers)
{
var result = new StringBuilder();
var writer = new StringWriter(result);
var options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = blankLinesBetweenMembers;
options.ElseOnClosing = true;
options.VerbatimOrder = true;
options.BracingStyle = "C";
// generate the code:
codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options);
// send it to the StringBuilder object:
writer.Flush();
return result.ToString();
}
/// <summary>
/// Build the assembly using CodeDom.
/// </summary>
/// <param name="compiler">instance of compiler</param>
/// <param name="localVars">string with local variable declarations, generated from expression</param>
/// <param name="expression">expression to be compiled</param>
/// <param name="variables">types of values in this dictionary determine local variable types</param>
/// <param name="returnsBool">should be true if the expression must return a boolean</param>
/// <returns>C# source</returns>
private static string BuildSource(CodeDomProvider compiler, string localVars, string expression, Dictionary<string, object> variables, bool returnsBool)
{
var sw = new StringWriter();
var ns = new CodeNamespace("ExpressionEvaluator");
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
ns.Imports.Add(new CodeNamespaceImport("Imarda.Lib"));
ns.Imports.Add(new CodeNamespaceImport("IXLCompiler"));
var decl = new CodeTypeDeclaration("Calculator") { IsClass = true, Attributes = MemberAttributes.Public };
var method = new CodeMemberMethod { Name = "Evaluate" };
method.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Dictionary<string, object>)), "args"));
method.ReturnType = new CodeTypeReference(returnsBool ? typeof(bool) : typeof(object));
method.Comments.Add(new CodeCommentStatement("Calculate an expression", true));
method.Attributes = MemberAttributes.Public;
var stmt = method.Statements;
foreach (var key in variables.Keys)
{
// only generate local variable decl/assignment if the variable occurs on the expression
if (Regex.IsMatch(expression, @"\b" + Regex.Escape(key) + @"\b"))
{
object obj = variables[key];
Type type = obj == null ? typeof(string) : obj.GetType();
var vardecl = string.Format("{0} {1} = args.ContainsKey(\"{1}\") ? ({0})(args[\"{1}\"]) : default({0})", type, key);
stmt.Add(new CodeSnippetExpression(vardecl));
}
}
if (!string.IsNullOrEmpty(localVars)) stmt.Add(new CodeSnippetStatement(localVars));
stmt.Add(new CodeSnippetStatement("#line 1"));
stmt.Add(new CodeAssignStatement(new CodeSnippetExpression(returnsBool ? "bool result" : "object result"), new CodeSnippetExpression(expression)));
stmt.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("result")));
decl.Members.Add(method);
ns.Types.Add(decl);
compiler.GenerateCodeFromNamespace(ns, sw, new CodeGeneratorOptions
{
IndentString = "\t",
BlankLinesBetweenMembers = false
});
sw.Close();
return sw.ToString();
}
private static string GenerateCode(CodeObject c, CodeDomProvider provider)
{
var sb = new StringBuilder();
var writer = new StringWriter(sb);
var options = new CodeGeneratorOptions();
if (c is CodeStatement)
{
provider.GenerateCodeFromStatement((CodeStatement)c, writer, options);
}
else if (c is CodeCompileUnit)
{
provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options);
}
else if (c is CodeExpression)
{
provider.GenerateCodeFromExpression((CodeExpression)c, writer, options);
}
else if (c is CodeTypeMember)
{
provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options);
}
else if (c is CodeTypeDeclaration)
{
provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options);
}
else if (c is CodeNamespace)
{
provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options);
}
else
{
throw new ArgumentException($"Tests not set up for unexpected type: {c.GetType()}");
}
return sb.ToString();
}
private static string GenerateCode(CodeObject c, CodeDomProvider provider)
{
var sb = new StringBuilder();
var writer = new StringWriter(sb);
var options = new CodeGeneratorOptions();
if (c is CodeStatement)
{
provider.GenerateCodeFromStatement((CodeStatement)c, writer, options);
}
else if (c is CodeCompileUnit)
{
provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options);
}
else if (c is CodeExpression)
{
provider.GenerateCodeFromExpression((CodeExpression)c, writer, options);
}
else if (c is CodeTypeMember)
{
provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options);
}
else if (c is CodeTypeDeclaration)
{
provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options);
}
else if (c is CodeNamespace)
{
provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options);
}
else
{
Assert.False(true, $"Unknown type: {c.GetType()}");
}
return sb.ToString();
}
