// 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}"); } } }