// Writing validation Methhod strucutre for webmethod
public void WriteValidationMethodStructure(CSharpFile file, DocumentScript script)
{
foreach (MethodDeclaration expr in file.IndexOfWebMthdDecl)
{
// for adding method before the webmethod
var copy = (MethodDeclaration)expr.Clone();
var chldOfTypPar = expr.GetChildByRole(Roles.Parameter);
var mtdhName = expr.Name;
var chdMtdhName = "Valid" + mtdhName;
var validationMthd = allPatterns.ValidationMthd(chdMtdhName);
bool validMethodPresent = false;
if (chldOfTypPar != null)
{
if (expr.PrevSibling != null && expr.PrevSibling.GetType().Name == "MethodDeclaration")
{
if (expr.PrevSibling.GetText().Contains(chdMtdhName))
{
validMethodPresent = true;
}
}
if (!validMethodPresent)
{
script.InsertBefore(expr, validationMthd);
}
}
}
}
public override void Transform(ToSqlItem item, EtlStatsScope stats, EtlProcessState state)
{
_stats = stats;
if (item.IsDelete == false)
{
Current = item;
DocumentScript.Run(Context, Context, "execute", new object[] { Current.Document }).Dispose();
}
// ReSharper disable once ForCanBeConvertedToForeach
for (int i = 0; i < _tablesForScript.Count; i++)
{
// delete all the rows that might already exist there
var sqlTable = _tablesForScript[i];
if (sqlTable.InsertOnlyMode)
{
continue;
}
GetOrAdd(sqlTable.TableName).Deletes.Add(item);
}
}
public void RemoveAccessControlCheckAccess(CSharpFile file, DocumentScript script, string checkAccessMethodName)
{
foreach (ExpressionStatement accessControlExpr in file.IndexofExprStmtCheckAccess)
{
script.Remove(accessControlExpr, true);
}
}
// Adding call to validation method inside try catch statement
public void WriteIfElseStructureInWebmethodTry(CSharpFile file, DocumentScript script)
{
foreach (var expr in file.IndexOfTryCatchStmt)
{
var copy = (TryCatchStatement)expr.Clone();
var parentMethod = expr.GetParent <MethodDeclaration>();
var methodName = "Valid" + parentMethod.Name;
var chldOfTypPar = parentMethod.GetChildByRole(Roles.Parameter);
if (chldOfTypPar != null)
{
bool foundIfElseDecl = false;
var trySecondChild = expr.FirstChild.NextSibling.FirstChild.NextSibling;
foreach (var expression in trySecondChild.Parent.Children.OfType <IfElseStatement>())
{
if (expression.GetText().Contains(methodName))
{
foundIfElseDecl = true;
}
}
if (!foundIfElseDecl)
{
script.InsertBefore(trySecondChild, allPatterns.IfElseTryCall(methodName));
}
}
}
}
//Add Using ORP; Decl in file
public void AddUsingAPIDecl(CSharpFile file, DocumentScript script)
{
var firstUsingExpr = file.IndexOfUsingDecl.First();
var copy = (UsingDeclaration)firstUsingExpr.Clone();
var parentDecl = firstUsingExpr.Parent;
bool foundWebMethod = false;
bool founORPDecl = false;
foreach (var method in parentDecl.Descendants.OfType <MethodDeclaration>())
{
if (method.FirstChild.GetText().Contains("WebMethod"))
{
foundWebMethod = true;
break;
}
}
foreach (var otherUsingExpr in firstUsingExpr.Parent.Children.OfType <UsingDeclaration>())
{
if (otherUsingExpr.Match(allPatterns.ORPUsingDecl()).Success)
{
founORPDecl = true;
break;
}
}
if (foundWebMethod && !founORPDecl)
{
script.InsertBefore(file.IndexOfUsingDecl.Last(), allPatterns.ORPUsingDecl());
}
// if (!(Path.GetDirectoryName(file.fileName).EndsWith("ORP")) && foundWebMethod && !founORPDecl)
// script.InsertBefore(file.IndexOfUsingDecl.Last().NextSibling, allPatterns.ORPUsingDecl());
}
private void DummyTextForTryCallValidation(CSharpFile file, DocumentScript script)
{
foreach (var expr in file.IndexOfIfElStmtValidation)
{
script.InsertText(script.GetCurrentOffset(expr.StartLocation), "DummyText ");
}
}
public override void Transform(ToOlapItem item, OlapEtlStatsScope stats, EtlProcessState state)
{
// Tombstones extraction is skipped by OLAP ETL. This must never happen
Debug.Assert(item.IsDelete == false,
$"Invalid item '{item.DocumentId}', OLAP ETL shouldn't handle tombstones");
_stats = stats;
Current = item;
DocumentScript.Run(Context, Context, "execute", new object[] { Current.Document }).Dispose();
}
public void WriteValidationMethodBody(CSharpFile file, DocumentScript script)
{
foreach (var expr in file.IndexOfWebMthdDecl)
{
// if parameters are present, go to next iteration without doing anything.
if (expr.Parameters.Count != 0)
{
continue;
}
if (expr.Name != "Valid" + (expr.NextSibling.GetChildByRole(Roles.Identifier).GetText()))
{
continue;
}
// logic to insert parameters to validation Method.
var copy = (MethodDeclaration)expr.Clone();
string str = string.Join(", ", from parameter
in expr.NextSibling.Descendants.OfType <ParameterDeclaration>()
select parameter.GetText());
var chldOfTypPar = expr.GetChildByRole(Roles.RPar);
int offset = script.GetCurrentOffset(chldOfTypPar.StartLocation);
script.InsertText(offset, str);
// Insert Static keyword to validation method.
script.InsertText(script.GetCurrentOffset(expr.ReturnType.StartLocation), "static ");
// logic to insert if else statements inside validation Method body
int offset1 = script.GetCurrentOffset(expr.LastChild.FirstChild.EndLocation);
var locationToInsert = expr.LastChild.LastChild.PrevSibling;
script.InsertBefore(locationToInsert, allPatterns.ValidationFieldDecl());
foreach (var inv in expr.NextSibling.Children.OfType <ParameterDeclaration>())
{
string dataType = inv.FirstChild.GetText();
string varName = inv.LastChild.GetText();
if (dataType.Contains("int"))
{
script.InsertBefore(locationToInsert, allPatterns.IfElStmtInt(varName));
}
else if (dataType.Contains("string") || dataType.Contains("String"))
{
script.InsertBefore(locationToInsert, allPatterns.IfElStmtStr(varName));
}
else if (dataType.Contains("float") || dataType.Contains("decimal") || dataType.Contains("Decimal"))
{
script.InsertBefore(locationToInsert, allPatterns.IfElseFloatDecimal(varName));
}
else
{
script.InsertText(script.GetCurrentOffset(locationToInsert.StartLocation), "DummyText_DatatypeIsDifferent ");
}
}
}
}
void UpdateField(IField oldField, CodeMemberField newField)
{
DomRegion region = oldField.Region;
DocumentScript script = GetScript(region.FileName);
int offset = script.GetCurrentOffset(region.Begin);
int endOffset = script.GetCurrentOffset(region.End);
string code = GenerateField(newField);
script.Replace(offset, endOffset - offset, code);
}
// Checking Whether Try Catch is Present in WebMethod
public void CheckTryCatchInWebMethodBody(CSharpFile file, DocumentScript script)
{
foreach (MethodDeclaration expr in file.IndexOfWebMthdDecl)
{
var copy = (MethodDeclaration)expr.NextSibling.Clone();
if (expr.NextSibling.FirstChild.GetText().Contains("WebMethod") &&
!expr.NextSibling.Descendants.OfType <TryCatchStatement>().Any())
{
script.InsertText(script.GetCurrentOffset(expr.NextSibling.StartLocation), "DummyText_TryCatchNotPresent");
}
}
}
void SaveInitializeComponents(CodeMemberMethod codeMethod)
{
var bodyRegion = initializeComponents.BodyRegion;
DocumentScript script = GetScript(bodyRegion.FileName);
string newline = DocumentUtilities.GetLineTerminator(script.OriginalDocument, bodyRegion.BeginLine);
string indentation = DocumentUtilities.GetIndentation(script.OriginalDocument, bodyRegion.BeginLine);
string code = "{" + newline + GenerateInitializeComponents(codeMethod, indentation, newline) + indentation + "}";
int startOffset = script.GetCurrentOffset(bodyRegion.Begin);
int endOffset = script.GetCurrentOffset(bodyRegion.End);
script.Replace(startOffset, endOffset - startOffset, code);
}
void CreateField(CodeMemberField newField)
{
// insert new field below InitializeComponents()
var bodyRegion = initializeComponents.BodyRegion;
DocumentScript script = GetScript(bodyRegion.FileName);
string newline = DocumentUtilities.GetLineTerminator(script.OriginalDocument, bodyRegion.BeginLine);
string indentation = DocumentUtilities.GetIndentation(script.OriginalDocument, bodyRegion.BeginLine);
var insertionLocation = new TextLocation(bodyRegion.EndLine + 1, 1);
int insertionOffset = script.GetCurrentOffset(insertionLocation);
string code = indentation + GenerateField(newField) + newline;
script.InsertText(insertionOffset, code);
}
private void HandleSingleTimeSeriesSegment(string loadBehaviorFunction, EtlStatsScope stats, EtlProcessState state)
{
var docId = Current.DocumentId;
var segmentEntry = Current.TimeSeriesSegmentEntry;
var doc = Database.DocumentsStorage.Get(Context, docId, DocumentFields.Default);
if (doc == null)
{
//Through replication the Etl source database can have time-series without its document.
//This is a rare situation and we will skip Etl this time-series and will mark the document so when it will be Etl we will send all its time-series with it
(state.SkippedTimeSeriesDocs ??= new HashSet <string>()).Add(docId);
return;
}
var timeSeriesEntries = segmentEntry.Segment.YieldAllValues(Context, segmentEntry.Start, false);
if (loadBehaviorFunction != null && FilterSingleTimeSeriesSegmentByLoadBehaviorScript(ref timeSeriesEntries, docId, segmentEntry, loadBehaviorFunction))
{
return;
}
if (doc.Etag > segmentEntry.Etag)
{
//There is a chance that the document didn't Etl yet so we push it with the time-series to be sure
doc = Database.DocumentsStorage.Get(Context, docId);
if (DocumentScript != null)
{
Current.Document = doc;
DocumentScript.Run(Context, Context, "execute", new object[] { doc }).Dispose();
if (_currentRun.IsDocumentLoadedToSameCollection(docId) == false)
{
return;
}
}
else
{
_currentRun.PutFullDocument(docId, doc.Data);
}
}
var timeSeriesName = Database.DocumentsStorage.TimeSeriesStorage.GetTimeSeriesNameOriginalCasing(Context, docId, segmentEntry.Name);
foreach (var entry in timeSeriesEntries)
{
_currentRun.AddTimeSeries(docId, timeSeriesName, entry);
}
}
public override void Transform(ElasticSearchItem item, EtlStatsScope stats, EtlProcessState state)
{
if (item.IsDelete == false)
{
Current = item;
DocumentScript.Run(Context, Context, "execute", new object[] { Current.Document }).Dispose();
}
for (int i = 0; i < _indexesForScript.Count; i++)
{
// delete all the rows that might already exist there
var elasticIndex = _indexesForScript[i];
GetOrAdd(elasticIndex.IndexName).Deletes.Add(item);
}
}
DocumentScript GetScript(string fileName)
{
DocumentScript script;
var fileNameObj = FileName.Create(fileName);
if (scripts.TryGetValue(fileNameObj, out script))
{
return(script);
}
IDocument document = context.GetDocument(fileNameObj);
var ctx = SDRefactoringContext.Create(fileNameObj, document);
script = new DocumentScript(document, FormattingOptionsFactory.CreateSharpDevelop(), new TextEditorOptions());
scripts.Add(fileNameObj, script);
return(script);
}
public void initializeExpr(Solution solution, int choice, string checkAccessMethodName)
{
foreach (var file in solution.AllFiles)
{
if (file.IndexOfWebMthdDecl.Count == 0 &&
file.IndexOfIfElStmt.Count == 0 &&
file.IndexOfTryCatchStmt.Count == 0 &&
file.IndexOfClassDecl.Count == 0 &&
file.IndexOfUsingDecl.Count == 0)
{
continue;
}
file.syntaxTree.Freeze();
// Create a document containing the file content:
var document = new StringBuilderDocument(file.originalText);
var formattingOptions = FormattingOptionsFactory.CreateAllman();
var options = new TextEditorOptions();
using (var script = new DocumentScript(document, formattingOptions, options))
{
switch (choice)
{
case 1: //AddUsingAPIDecl(file, script);
RemoveAccessControlCheckAccess(file, script, checkAccessMethodName);
WriteValidationMethodStructure(file, script);
WriteIfElseStructureInWebmethodTry(file, script);
break;
case 2: WriteValidationMethodBody(file, script);
WriteAccessControlStmtInTryCatch(file, script, checkAccessMethodName);
InsertParametersIfElseInWebmethodTry(file, script);
DummyTextForTryCallValidation(file, script);
AddPageNameGlobalinClass(file, script);
CheckTryCatchInWebMethodBody(file, script);
break;
}
}
//File.WriteAllText(Path.ChangeExtension(file.fileName, ".output.cs"), document.Text);
File.WriteAllText(file.fileName, document.Text);
}
Console.WriteLine("Done. Press Any Key to Exit..............");
}
DocumentScript GetScript(string fileName)
{
DocumentScript script;
var fileNameObj = FileName.Create(fileName);
if (scripts.TryGetValue(fileNameObj, out script))
{
return(script);
}
IDocument document = context.GetDocument(fileNameObj);
var ctx = SDRefactoringContext.Create(fileNameObj, document);
var formattingOptions = AlFormattingPolicies.Instance.GetProjectOptions(compilation.GetProject());
script = new DocumentScript(document, formattingOptions.OptionsContainer.GetEffectiveOptions(), new TextEditorOptions());
scripts.Add(fileNameObj, script);
return(script);
}
private static string RemoveMethods(string code, IEnumerable <MethodVisitorResult> methods)
{
var document = new StringBuilderDocument(code);
using (var script = new DocumentScript(
document,
FormattingOptionsFactory.CreateAllman(),
new TextEditorOptions()))
{
foreach (var method in methods)
{
var offset = script.GetCurrentOffset(method.MethodDefinition.GetRegion().Begin);
script.Replace(method.MethodDefinition, new MethodDeclaration());
script.Replace(offset, new MethodDeclaration().GetText().Trim().Length, "");
}
}
return(document.Text);
}
private static string RemoveClasses(string code, IEnumerable <TypeDeclaration> classes)
{
var document = new StringBuilderDocument(code);
using (
var script = new DocumentScript(
document,
FormattingOptionsFactory.CreateAllman(),
new TextEditorOptions()))
{
foreach (var @class in classes)
{
var offset = script.GetCurrentOffset(@class.GetRegion().Begin);
script.Replace(@class, new TypeDeclaration());
script.Replace(offset, new TypeDeclaration().GetText().Trim().Length, "");
}
}
return(document.Text);
}
void RemoveField(IField field)
{
DomRegion region = field.Region;
DocumentScript script = GetScript(region.FileName);
int offset = script.GetCurrentOffset(region.Begin);
int endOffset = script.GetCurrentOffset(region.End);
IDocumentLine line = script.CurrentDocument.GetLineByOffset(endOffset);
if (endOffset == line.EndOffset)
{
endOffset += line.DelimiterLength; // delete the whole line
// delete indentation in front of the line
while (offset > 0 && IsTabOrSpace(script.CurrentDocument.GetCharAt(offset - 1)))
{
offset--;
}
}
script.RemoveText(offset, endOffset - offset);
}
void CreateField(CodeMemberField newField)
{
// insert new field below the last field or InitializeComponents()
IField field = null;
if (formClass != null)
{
field = formClass.Fields.LastOrDefault(f => string.Equals(f.Region.FileName,
initializeComponents.Region.FileName,
StringComparison.OrdinalIgnoreCase));
}
var bodyRegion = field != null ? field.BodyRegion : initializeComponents.BodyRegion;
DocumentScript script = GetScript(bodyRegion.FileName);
string newline = DocumentUtilities.GetLineTerminator(script.OriginalDocument, bodyRegion.BeginLine);
string indentation = DocumentUtilities.GetIndentation(script.OriginalDocument, bodyRegion.BeginLine);
var insertionLocation = new TextLocation(bodyRegion.EndLine + 1, 1);
int insertionOffset = script.GetCurrentOffset(insertionLocation);
string code = indentation + GenerateField(newField) + newline;
script.InsertText(insertionOffset, code);
}
public static string ReplaceStringLiteralsWithVariables(string text, IEnumerable <string> macros, Func <int, int, string, string, string> onReplace)
{
var setting = new CompilerSettings();
foreach (var macro in macros)
{
setting.ConditionalSymbols.Add(macro);
}
var tree = SyntaxTree.Parse(text, string.Empty, setting);
tree.Freeze();
var doc = new StringBuilderDocument(text);
using (var editor = new DocumentScript(doc, FormattingOptionsFactory.CreateAllman(), TextEditorOptions.Default)) {
var originDoc = editor.OriginalDocument;
foreach (var node in tree.Descendants.OfType <PrimitiveExpression>().Where(e => e.Value is string))
{
var line = originDoc.GetLineByNumber(node.StartLocation.Line);
var result = onReplace(node.StartLocation.Line, node.StartLocation.Column, originDoc.GetText(line), node.Value as string);
if (result != null)
{
var names = result.Split('.');
Expression exp = new IdentifierExpression(names.First());
foreach (var name in names.Skip(1))
{
exp = exp.Member(name);
}
editor.Replace(node, exp);
}
}
}
return(doc.Text);
}
public void InsertParametersIfElseInWebmethodTry(CSharpFile file, DocumentScript script)
{
foreach (var expr in file.IndexOfIfElStmt)
{
//check if parameters are passed before, go to next iteration
if (!(expr.Descendants.OfType <InvocationExpression>().First().GetText().Split("()".ToCharArray())[1] == ""))
{
continue;
}
// logic to add parameters in if block (in try catch of webmethod) to Validation Method.
var copy = (IfElseStatement)expr.Clone();
var ParentExpr = expr.GetParent <MethodDeclaration>();
string str = string.Join(", ", from parameter
in ParentExpr.Descendants.OfType <ParameterDeclaration>()
select parameter.Name);
int parameterOffset = script.GetCurrentOffset(expr.GetChildByRole(Roles.RPar).StartLocation) - 1;
script.InsertText(parameterOffset, str);
// putting Return Vriable Name in If Else Block.
if (expr.GetParent <MethodDeclaration>().ReturnType.GetText() != "void")
{
var returnVar = expr.GetParent <MethodDeclaration>().Body.LastChild.PrevSibling.FirstChild;
int retValueOffset = script.GetCurrentOffset(expr.LastChild.LastChild.StartLocation);
if (returnVar.GetText() == "return")
{
string retString = returnVar.NextSibling.GetText();
script.InsertText(retValueOffset, " " + retString);
}
else
{
script.InsertText(retValueOffset, " DummyText");
}
}
}
}
// Add pageName parameter in clas global declaration
public void AddPageNameGlobalinClass(CSharpFile file, DocumentScript script)
{
foreach (var expr in file.IndexOfClassDecl)
{
bool foundPageNameGlobalInClass = false;
var copy = (TypeDeclaration)expr.Clone();
foreach (var TypeMember in expr.Members.OfType <FieldDeclaration>())
{
if (TypeMember.Match(allPatterns.PageNameGlobalFieldDecl(expr.Name + ".aspx")).Success)
{
foundPageNameGlobalInClass = true;
//break;
}
if (TypeMember.Match(allPatterns.PageNameGlobalFieldDecl1(expr.Name + ".aspx")).Success)
{
script.Remove(TypeMember, true);
}
}
if (!foundPageNameGlobalInClass)
{
script.InsertBefore(expr.Members.First(), allPatterns.PageNameGlobalFieldDecl(expr.Name + ".aspx"));
}
}
}
// To write access control statement in try block of webmethod
public void WriteAccessControlStmtInTryCatch(CSharpFile file, DocumentScript script, string checkAccessMethodName)
{
foreach (var expr in file.IndexOfTryCatchStmt)
{
bool foundCheckAccessControl = false;
var copy = (TryCatchStatement)expr.Clone();
var AccessControlPattern = allPatterns.AccessControlExpression(checkAccessMethodName);
foreach (var expression in expr.FirstChild.NextSibling.Children.OfType <ExpressionStatement>())
{
if (expression.Match(AccessControlPattern).Success)
{
foundCheckAccessControl = true;
}
}
if (!foundCheckAccessControl)
{
string className = (expr.GetParent <TypeDeclaration>().Name.ToString());
try
{
script.InsertBefore(expr.FirstChild.NextSibling.FirstChild.NextSibling.NextSibling, AccessControlPattern);
if (!(AccessControlPageNames.Contains(className)))
{
AccessControlPageNames.Add(className);
}
}
catch (Exception)
{
script.InsertBefore(expr.FirstChild.NextSibling.FirstChild.NextSibling, AccessControlPattern);
if (!(AccessControlPageNames.Contains(className)))
{
AccessControlPageNames.Add(className);
}
}
}
}
}
public static void Main(string[] args)
{
/*
* if (args.Length == 0) {
* Console.WriteLine("Please specify the path to a .sln file on the command line");
*
* Console.Write("Press any key to continue . . . ");
* Console.ReadKey(true);
* return;
* }
*
*/
List <string> list = new List <string>();
Solution solution = new Solution("C:\\Martin\\GitHub\\HotFixForUnity\\AddMethodTool\\AddMethod.sln");
//Solution solution = new Solution(args[0]);
// foreach (var file in solution.AllFiles) {
// var astResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile);
// foreach (var invocation in file.SyntaxTree.Descendants.OfType<InvocationExpression>()) {
// // Retrieve semantics for the invocation
// var rr = astResolver.Resolve(invocation) as InvocationResolveResult;
// if (rr == null) {
// // Not an invocation resolve result - e.g. could be a UnknownMemberResolveResult instead
// continue;
// }
// if (rr.Member.FullName != "System.String.IndexOf") {
// // Invocation isn't a string.IndexOf call
// continue;
// }
// if (rr.Member.Parameters.First().Type.FullName != "System.String") {
// // Ignore the overload that accepts a char, as that doesn't take a StringComparison.
// // (looking for a char always performs the expected ordinal comparison)
// continue;
// }
// if (rr.Member.Parameters.Last().Type.FullName == "System.StringComparison") {
// // Already using the overload that specifies a StringComparison
// continue;
// }
// Console.WriteLine(invocation.GetRegion() + ": " + invocation.GetText());
// file.IndexOfInvocations.Add(invocation);
// }
// }
// Console.WriteLine("Found {0} places to refactor in {1} files.",
// solution.AllFiles.Sum(f => f.IndexOfInvocations.Count),
// solution.AllFiles.Count(f => f.IndexOfInvocations.Count > 0));
Console.Write("Apply refactorings? ");
//string answer = Console.ReadLine();
//if ("yes".Equals(answer, StringComparison.OrdinalIgnoreCase) || "y".Equals(answer, StringComparison.OrdinalIgnoreCase))
{
foreach (var file in solution.AllFiles)
{
// if (file.IndexOfInvocations.Count == 0)
// continue;
// DocumentScript expects the the AST to stay unmodified (so that it fits
// to the document state at the time of the DocumentScript constructor call),
// so we call Freeze() to prevent accidental modifications (e.g. forgetting a Clone() call).
file.SyntaxTree.Freeze();
// AST resolver used to find context for System.StringComparison generation
var compilation = file.Project.Compilation;
var astResolver = new CSharpAstResolver(compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile);
// Create a document containing the file content:
var document = new StringBuilderDocument(file.OriginalText);
var formattingOptions = FormattingOptionsFactory.CreateAllman();
var options = new TextEditorOptions();
// using (var script = new DocumentScript(document, formattingOptions, options)) {
// foreach (InvocationExpression expr in file.IndexOfInvocations) {
// // Generate a reference to System.StringComparison in this context:
// var astBuilder = new TypeSystemAstBuilder(astResolver.GetResolverStateBefore(expr));
// IType stringComparison = compilation.FindType(typeof(StringComparison));
// AstType stringComparisonAst = astBuilder.ConvertType(stringComparison);
//
// // Alternative 1: clone a portion of the AST and modify it
// var copy = (InvocationExpression)expr.Clone();
// copy.Arguments.Add(stringComparisonAst.Member("Ordinal"));
// script.Replace(expr, copy);
//
// // // Alternative 2: perform direct text insertion
// // int offset = script.GetCurrentOffset(expr.RParToken.StartLocation);
// // script.InsertText(offset, ", " + stringComparisonAst.GetText() + ".Ordinal");
// }
// }
using (var script = new DocumentScript(document, formattingOptions, options))
{
CSharpParser parser = new CSharpParser();
//SyntaxTree syntaxTree = parser.Parse(code, srcFilePath);
SyntaxTree syntaxTree = file.SyntaxTree;
foreach (var classDec in syntaxTree.Descendants.OfType <TypeDeclaration>())
{
if (classDec.ClassType == ClassType.Class || classDec.ClassType == ClassType.Struct)
{
var className = classDec.Name;
foreach (var method in classDec.Children.OfType <MethodDeclaration>())
{
var returnType = method.ReturnType.ToString();
if (returnType.Contains("IEnumerator") || returnType.Contains("IEnumerable")) // 暂不支持yield!
{
continue;
}
Console.WriteLine("className:" + className + " method:" + method.Name);
AstNodeCollection <ParameterDeclaration> paramlist = method.Parameters;
string strParaType = string.Format("{0},{1}", className, method.Name);
string numberType = ",{0}";
string numberPara = ", typeof(object)";//兼容性思路，无论是静态还是非静态都传入object
string strPara = ", null";
if ((method.Modifiers & Modifiers.Static) != Modifiers.Static)
{
strPara = ", this";
}
int number = 1;
foreach (ParameterDeclaration param in paramlist)
{
Console.WriteLine("param " + param.Name);
strPara += string.Format(", {0}", param.Name);
numberType += string.Format(",{0}{1}{2}", "{", number, "}");
numberPara += string.Format(", typeof({0})", param.Type);
number++;
}
int offset = script.GetCurrentOffset(method.Body.LBraceToken.StartLocation);
script.InsertText(offset + 1, "\n" +
"\n" +
string.Format("if (FixUtil.Instance.NeedFix(\"{0}.{1}\"))\n", className, method.Name) +
"{\n" +
string.Format(" string strParameter = string.Format(\"{0}{1}\"{2});\n", strParaType, numberType, numberPara) +
string.Format(" FixUtil.Instance.Fix(strParameter{0});\n", strPara) +
" return;\n" +
"}\n");
// script.InsertText(offset + 1, "\n" +
// "\n" +
// string.Format("if (FixUtil.Instance.NeedFix("+className+"."+method.Name+"))\n" +
// "{\n" +
// string.Format(" FixUtil.Instance.Fix(\"{0}.{1}\"{2});\n", className, method.Name, str) +
// " return;\n" +
// "}\n");
}
}
}
}
File.WriteAllText(Path.ChangeExtension(file.FileName, ".output.cs"), document.Text);
}
string text = Console.ReadLine();
}
}
public override void Transform(RavenEtlItem item)
{
Current = item;
_currentRun = new RavenEtlScriptRun();
if (item.IsDelete == false)
{
switch (item.Type)
{
case EtlItemType.Document:
if (_script.HasTransformation)
{
// first, we need to delete docs prefixed by modified document ID to properly handle updates of
// documents loaded to non default collections
ApplyDeleteCommands(item, OperationType.Put);
DocumentScript.Run(Context, Context, "execute", new object[] { Current.Document }).Dispose();
if (_script.HasLoadCounterBehaviors && _script.TryGetLoadCounterBehaviorFunctionFor(item.Collection, out var function))
{
foreach (var counter in GetCountersFor(Current))
{
using (var result = BehaviorsScript.Run(Context, Context, function, new object[] { item.DocumentId, counter.Name }))
{
if (result.BooleanValue == true)
{
_currentRun.AddCounter(item.DocumentId, counter.Name, counter.Value);
}
}
}
}
}
else
{
_currentRun.PutFullDocument(item.DocumentId, item.Document.Data, GetAttachmentsFor(item), GetCountersFor(item));
}
break;
case EtlItemType.Counter:
if (_script.HasTransformation)
{
if (_script.HasLoadCounterBehaviors == false)
{
break;
}
if (_script.TryGetLoadCounterBehaviorFunctionFor(item.Collection, out var function) == false)
{
break;
}
using (var result = BehaviorsScript.Run(Context, Context, function, new object[] { item.DocumentId, item.CounterName }))
{
if (result.BooleanValue == true)
{
_currentRun.AddCounter(item.DocumentId, item.CounterName, item.CounterValue);
}
}
}
else
{
_currentRun.AddCounter(item.DocumentId, item.CounterName, item.CounterValue);
}
break;
}
}
else
{
switch (item.Type)
{
case EtlItemType.Document:
if (_script.HasTransformation)
{
Debug.Assert(item.IsAttachmentTombstone == false, "attachment tombstones are tracked only if script is empty");
bool shouldDelete = true;
if (_script.HasDeleteDocumentsBehaviors && _script.TryGetDeleteDocumentBehaviorFunctionFor(item.Collection, out var function))
{
using (var result = BehaviorsScript.Run(Context, Context, function, new object[] { item.DocumentId }))
{
shouldDelete = result.BooleanValue == true;
}
}
if (shouldDelete)
{
ApplyDeleteCommands(item, OperationType.Delete);
}
}
else
{
if (item.IsAttachmentTombstone == false)
{
_currentRun.Delete(new DeleteCommandData(item.DocumentId, null));
}
else
{
var(doc, attachmentName) = AttachmentsStorage.ExtractDocIdAndAttachmentNameFromTombstone(Context, item.AttachmentTombstoneId);
_currentRun.DeleteAttachment(doc, attachmentName);
}
}
break;
case EtlItemType.Counter:
var(docId, counterName) = CountersStorage.ExtractDocIdAndCounterNameFromTombstone(Context, item.CounterTombstoneId);
if (_script.HasTransformation)
{
if (_script.HasLoadCounterBehaviors == false)
{
break;
}
if (_script.TryGetLoadCounterBehaviorFunctionFor(item.Collection, out var function) == false)
{
break;
}
using (var result = BehaviorsScript.Run(Context, Context, function, new object[] { docId, counterName }))
{
if (result.BooleanValue == true)
{
_currentRun.DeleteCounter(docId, counterName);
}
}
}
else
{
_currentRun.DeleteCounter(docId, counterName);
}
break;
}
}
_commands.AddRange(_currentRun.GetCommands());
}
internal void OpenDocumentPanel(DocumentScript DS)
{
OpenDocumentPanel(DS.DocSprite);
}
/// <summary>
/// 代码注入！ GOGOGO
/// </summary>
/// <param name="srcFilePath"></param>
/// <param name="outputFilePath"></param>
public void Inject(string srcFilePath, string outputFilePath)
{
UTF8Encoding utf8 = new UTF8Encoding(false);
var predefineSymbolsSb = new StringBuilder();
if (_defineSymbols != null)
{
foreach (var symbol in _defineSymbols)
{
predefineSymbolsSb.AppendFormat("#define {0}\n", symbol);
}
}
var code = File.ReadAllText(srcFilePath, Encoding.UTF8);
code = predefineSymbolsSb.ToString() + code; // 加入宏
var document = new StringBuilderDocument(code);
var formattingOptions = FormattingOptionsFactory.CreateAllman();
var options = new TextEditorOptions();
using (var script = new DocumentScript(document, formattingOptions, options))
{
CSharpParser parser = new CSharpParser();
SyntaxTree syntaxTree = parser.Parse(code, srcFilePath);
foreach (var classDec in syntaxTree.Descendants.OfType <TypeDeclaration>())
{
if (classDec.ClassType == ClassType.Class || classDec.ClassType == ClassType.Struct)
{
var className = classDec.Name;
foreach (var method in classDec.Children.OfType <MethodDeclaration>())
{
var returnType = method.ReturnType.ToString();
if (returnType.Contains("IEnumerator") || returnType.Contains("IEnumerable")) // 暂不支持yield!
{
continue;
}
var methodSegment = script.GetSegment(method);
var methodOffset = methodSegment.Offset; // 方法偏移
var paramsTypes = method.Parameters; //method.Children.OfType<ParameterDeclaration>();// typeName
var paramsTypesStrs = new List <string>(); // 参数
if (!method.HasModifier(Modifiers.Static))
{
paramsTypesStrs.Add("this"); // 非静态方法，加this
}
var paramsOutStrs = new List <string>(); // out 的参数
foreach (var paramsType in paramsTypes)
{
paramsTypesStrs.Add(paramsType.Name);
if (paramsType.ParameterModifier == ParameterModifier.Out)
{
// out 的参数
paramsOutStrs.Add(string.Format("{0} = default({1});", paramsType.Name, paramsType.Type));
}
}
if (_beforeInsert != null)
{
var insertBeforeText = _beforeInsert(className, method.Name, returnType,
paramsTypesStrs.ToArray(), paramsOutStrs.ToArray());
if (!string.IsNullOrEmpty(insertBeforeText))
{
script.InsertText(methodOffset, insertBeforeText);
}
}
foreach (var blockStatement in method.Descendants.OfType <BlockStatement>())
{
int insertOffset;
if (blockStatement.Statements.Count == 0) // 空函数
{
var segment = script.GetSegment(blockStatement);
insertOffset = segment.Offset + 1; // 越过"/"
}
else
{
var firstChildStatement = blockStatement.Statements.First();
var segment = script.GetSegment(firstChildStatement);
insertOffset = segment.Offset;
}
script.InsertText(insertOffset, _afterInsert(className, method.Name, returnType, paramsTypesStrs.ToArray(), paramsOutStrs.ToArray()));
break; // 仅对第一个方法包体(BlockStatement), 其它不是方法进行处理
}
}
}
}
}
var resultText = document.Text;
resultText = resultText.Substring(predefineSymbolsSb.Length); // 移除宏定义
File.WriteAllText(outputFilePath, resultText, utf8);
}
public override void Transform(RavenEtlItem item, EtlStatsScope stats, EtlProcessState state)
{
Current = item;
_currentRun ??= new RavenEtlScriptRun(stats);
if (item.IsDelete == false)
{
switch (item.Type)
{
case EtlItemType.Document:
if (_script.HasTransformation)
{
using (DocumentScript.Run(Context, Context, "execute", new object[] { Current.Document }))
{
ApplyDeleteCommands(item, OperationType.Put, out var isLoadedToDefaultCollectionDeleted);
if (_currentRun.IsDocumentLoadedToSameCollection(item.DocumentId) == false)
{
break;
}
if (_script.TryGetLoadCounterBehaviorFunctionFor(item.Collection, out var counterFunction))
{
var counterGroups = GetCounterGroupsFor(item);
if (counterGroups != null)
{
AddCounters(item.DocumentId, counterGroups, counterFunction);
}
}
if (_script.TryGetLoadTimeSeriesBehaviorFunctionFor(item.Collection, out var timeSeriesLoadBehaviorFunc))
{
if (isLoadedToDefaultCollectionDeleted || ShouldLoadTimeSeriesWithDoc(item, state))
{
var timeSeriesReaders = GetTimeSeriesFor(item, timeSeriesLoadBehaviorFunc);
if (timeSeriesReaders != null)
{
AddAndRemoveTimeSeries(item.DocumentId, timeSeriesReaders);
}
}
}
}
}
else
{
var attachments = GetAttachmentsFor(item);
var counterOperations = GetCounterOperationsFor(item);
var timeSeriesOperations = ShouldLoadTimeSeriesWithDoc(item, state) ? GetTimeSeriesOperationsFor(item) : null;
_currentRun.PutFullDocument(item.DocumentId, item.Document.Data, attachments, counterOperations, timeSeriesOperations);
}
break;
case EtlItemType.CounterGroup:
string cFunction = null;
if (_script.HasTransformation)
{
if (_script.MayLoadToDefaultCollection(item) == false)
{
break;
}
if (_script.TryGetLoadCounterBehaviorFunctionFor(item.Collection, out cFunction) == false)
{
break;
}
}
AddSingleCounterGroup(item.DocumentId, item.CounterGroupDocument, cFunction);
break;
case EtlItemType.TimeSeries:
string tsFunction = null;
if (_script.HasTransformation)
{
if (_script.MayLoadToDefaultCollection(item) == false)
{
break;
}
if (_script.TryGetLoadTimeSeriesBehaviorFunctionFor(item.Collection, out tsFunction) == false)
{
break;
}
}
HandleSingleTimeSeriesSegment(tsFunction, stats, state);
break;
}
}
else
{
switch (item.Type)
{
case EtlItemType.Document:
if (ShouldFilterOutDeletion(item))
{
break;
}
if (_script.HasTransformation)
{
Debug.Assert(item.IsAttachmentTombstone == false, "attachment tombstones are tracked only if script is empty");
ApplyDeleteCommands(item, OperationType.Delete, out _);
}
else
{
if (item.IsAttachmentTombstone == false)
{
_currentRun.Delete(new DeleteCommandData(item.DocumentId, null, null));
}
else
{
var(doc, attachmentName) = AttachmentsStorage.ExtractDocIdAndAttachmentNameFromTombstone(Context, item.AttachmentTombstoneId);
_currentRun.DeleteAttachment(doc, attachmentName);
}
}
break;
case EtlItemType.TimeSeries:
string function = null;
if (_script.HasTransformation)
{
if (_script.MayLoadToDefaultCollection(item) == false)
{
break;
}
if (_script.TryGetLoadTimeSeriesBehaviorFunctionFor(item.Collection, out function) == false)
{
break;
}
}
HandleSingleTimeSeriesDeletedRangeItem(item.TimeSeriesDeletedRangeItem, function);
break;
default:
throw new InvalidOperationException($"Dead Etl item can be of type {EtlItemType.Document} or {EtlItemType.TimeSeries} but got {item.Type}");
}
}
}
