public GeneratedCodeInfo CreateTestsNew(GeneratedCodeInfo generatedCodeInfo, TemplateInfo template, EventSpecificDataType eventData, string methodName, bool useAdvancedCode)
{
var resultCodeInfo = new GeneratedCodeInfo(generatedCodeInfo);
DefaultCodeTemplate defaultTemplate = LoadDefaultCodeTemplate(template, eventData);
string code = useAdvancedCode ? defaultTemplate.AdvancedUnitTestsCode : defaultTemplate.SimpleUnitTestsCode;
code = code.Replace("$(pkgname)", resultCodeInfo.Namespace);
code = code.Replace("$(clsname)", resultCodeInfo.ClassName);
resultCodeInfo.TestsCodeInfo.Code = resultCodeInfo.IsUseVSFormatting ? FormattingCode(code) : code;
resultCodeInfo.TestsCodeInfo.Path = Path.Combine(methodName, methodName + "Tests.cs");
return(resultCodeInfo);
}
public GeneratedCodeInfo CreateMainNew(GeneratedCodeInfo generatedCodeInfo,
TemplateInfo template,
EventSpecificDataType eventData,
string methodName,
bool useAdvancedCode,
string codeToInsert)
{
DefaultCodeTemplate defaultTemplate = LoadDefaultCodeTemplate(template, eventData);
StringBuilder code = new StringBuilder(useAdvancedCode ? defaultTemplate.AdvancedSourceCode : defaultTemplate.SimpleSourceCode);
code = code.Replace("$(pkgname)", generatedCodeInfo.Namespace);
code = code.Replace("$(clsname)", generatedCodeInfo.ClassName);
if (!string.IsNullOrEmpty(codeToInsert))
{
string codeString = code.ToString();
var defaultCode = GetSourceCodeBetweenRegion(codeString);
if (string.IsNullOrWhiteSpace(defaultCode))
{
var insertPattern = "#region MethodCode\r\n";
var insertIndex = codeString.IndexOf(insertPattern);
code = code.Insert(insertIndex + insertPattern.Length, codeToInsert);
}
else
{
code = code.Replace(defaultCode, codeToInsert);
}
}
if (eventData.EventSpecificData != EventSpecificData.None)
{
code = code.Insert(0, "#define EventDataIsAvailable\r\n");
}
generatedCodeInfo.MethodCodeInfo.Code = generatedCodeInfo.IsUseVSFormatting ? this.FormattingCode(code.ToString()) : code.ToString();
generatedCodeInfo.MethodCodeInfo.Path = Path.Combine(methodName, methodName + ".cs");
return(generatedCodeInfo);
}
public DefaultCodeTemplate GetDefaultCodeTemplate(string defaultTempalteFilePath, string templateName, string eventName)
{
DefaultCodeTemplate defaultTemlate = null;
if (this.iOWrapper.DirectoryExists(defaultTempalteFilePath))
{
var mappedTemplateName = TemplateMapper.GetAliasTemplateName(templateName);
var file = this.iOWrapper.DirectoryGetFiles(defaultTempalteFilePath)
.FirstOrDefault(fl => fl.Contains(mappedTemplateName + eventName));
if (file == null)
{
return(null);
}
XmlDocument doc = new XmlDocument();
doc.Load(file);
var node = doc.GetElementsByTagName("default_code_template")[0];
defaultTemlate = new DefaultCodeTemplate();
defaultTemlate.TempalteName = node.Attributes["templateName"]?.InnerText;
defaultTemlate.EventDataType = EventSpecificData.None;
EventSpecificData eventData;
if (Enum.TryParse <EventSpecificData>(node.Attributes["eventData"]?.InnerText, out eventData))
{
defaultTemlate.EventDataType = eventData;
}
defaultTemlate.WrapperSourceCode = node.SelectSingleNode("wrapper_code")?.InnerText;
defaultTemlate.SimpleSourceCode = node.SelectSingleNode("simple_code/source_code")?.InnerText;
defaultTemlate.SimpleUnitTestsCode = node.SelectSingleNode("simple_code/test_code")?.InnerText;
defaultTemlate.AdvancedSourceCode = node.SelectSingleNode("advanced_code/source_code")?.InnerText;
defaultTemlate.AdvancedUnitTestsCode = node.SelectSingleNode("advanced_code/test_code")?.InnerText;
}
return(defaultTemlate);
}
public GeneratedCodeInfo CreateWrapper(TemplateInfo template, EventSpecificDataType eventData, string methodName, bool useVSFormatting)
{
if (string.IsNullOrEmpty(methodName))
{
throw new ArgumentException("Method name can not be empty");
}
DefaultCodeTemplate defaultTemplate = LoadDefaultCodeTemplate(template, eventData);
string wrapperCode = defaultTemplate.WrapperSourceCode;
const string fncname = "FNCMethod";
var eventDataClass = eventData.EventDataClass;
var interfaceName = eventData.InterfaceName;
string methodNameWithOutSpases = Regex.Replace(methodName, "[^a-zA-Z0-9]+", string.Empty, RegexOptions.Compiled);
var clsname = "ArasCLS" + methodNameWithOutSpases;
var pkgname = "ArasPKG" + methodNameWithOutSpases;
if (!wrapperCode.EndsWith("\r\n"))
{
wrapperCode += "\r\n";
}
var resultCode = template.TemplateCode;
wrapperCode = wrapperCode.Insert(0, "[WrapperMethod]\r\n");
resultCode = resultCode.Replace("$(MethodCode)", wrapperCode);
resultCode = resultCode.Replace("$(pkgname)", pkgname);
resultCode = resultCode.Replace("$(clsname)", clsname);
resultCode = resultCode.Replace("$(interfacename)", interfaceName);
resultCode = resultCode.Replace("$(fncname)", fncname);
resultCode = resultCode.Replace("$(EventDataClass)", eventDataClass);
var tree = CSharpSyntaxTree.ParseText(resultCode);
SyntaxNode root = tree.GetRoot();
var member = root.DescendantNodes()
.OfType <AttributeSyntax>()
.Where(a => a.Name.ToString() == "WrapperMethod")
.FirstOrDefault();
var parentClassName = GetParentClassName(member);
var clss = root.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.FirstOrDefault(a => a.Identifier.Text.ToString() == parentClassName);
if (clss != null)
{
var clsWithModifier = clss.AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword));
clsWithModifier = clsWithModifier.NormalizeWhitespace();
root = root.ReplaceNode(clss, clsWithModifier);
}
resultCode = root.ToString().Replace("[WrapperMethod]", string.Empty);
GeneratedCodeInfo resultInfo = new GeneratedCodeInfo();
resultInfo.WrapperCodeInfo.Code = useVSFormatting ? FormattingCode(resultCode) : resultCode;
resultInfo.WrapperCodeInfo.Path = Path.Combine(methodName, methodName + "Wrapper.cs");
resultInfo.MethodName = methodName;
resultInfo.ClassName = clsname;
resultInfo.Namespace = pkgname;
resultInfo.MethodCodeParentClassName = parentClassName;
resultInfo.IsUseVSFormatting = useVSFormatting;
return(resultInfo);
}
