/// <summary> /// Deletes the name space using statements. /// </summary> /// <param name="instance">The instance.</param> public static void DeleteNameSpaceUsingStatements(this ProjectItem instance) { bool continueLoop = true; do { CodeElement codeElement = instance.FileCodeModel.CodeElements.Item(1); if (codeElement != null) { if (codeElement.Kind == vsCMElement.vsCMElementImportStmt) { EditPoint editPoint = codeElement.GetStartPoint().CreateEditPoint(); TextPoint textPoint = codeElement.GetEndPoint(); editPoint.Delete(textPoint); //// should get rid of the blank line! editPoint.Delete(1); } else { continueLoop = false; } } else { continueLoop = false; } }while (continueLoop); }
public override void UiBtnCommandAction(Object param) { if (string.IsNullOrWhiteSpace(UiCommandProppertyName)) { return; } if (SelectedCodeElement == null) { return; } if (SelectedCodeElement.CodeElementRef == null) { return; } CodeClass cc = SelectedCodeElement.CodeElementRef as CodeClass; if (SelectedViewModel != null) { SolutionProject prj = ComboItemsSourceProjects.Where(p => string.Equals(p.ProjectUniqueName, SelectedViewModel.RootNodeProjectName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault(); if (prj != null) { if (!string.Equals(SelectedProject.ProjectUniqueName, prj.ProjectUniqueName, StringComparison.OrdinalIgnoreCase)) { if (SelectedProject.ProjectRef.Object is VSProject) { (SelectedProject.ProjectRef.Object as VSProject).References.AddProject(prj.ProjectRef); SelectedProject.ProjectRef.Save(); } } } } //cc.AddProperty(UiCommandProppertyName , UiCommandProppertyName, "System.Data.Entity.DbSet<" + SelectedViewModelRootClass + ">", -1, vsCMAccess.vsCMAccessPublic, null); CodeProperty codeProperty = cc.AddProperty(UiCommandProppertyName, UiCommandProppertyName, "DbSet<" + SelectedViewModelRootClass + ">", -1, vsCMAccess.vsCMAccessPublic, null); EditPoint editPoint = codeProperty.Getter.StartPoint.CreateEditPoint(); editPoint.Delete(codeProperty.Getter.EndPoint); editPoint.Insert("get ;"); editPoint = codeProperty.Setter.StartPoint.CreateEditPoint(); editPoint.Delete(codeProperty.Setter.EndPoint); editPoint.Insert("set ;"); if (cc.ProjectItem != null) { if (cc.ProjectItem.IsDirty) { cc.ProjectItem.Save(); } } DoAnaliseDbContext(); }
private static async Task RemoveCommentsAsync(EditPoint objEditPt) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var template = GetTemplate(); int index = 0; while (index < template.Count) { var line = string.Empty; if (!objEditPt.AtEndOfDocument) { line = objEditPt.GetText(objEditPt.LineLength); } if (string.Equals(line, template[index])) { var newPoint = objEditPt.CreateEditPoint(); newPoint.LineDown(); if (!newPoint.AtEndOfDocument) { newPoint.StartOfLine(); } objEditPt.Delete(newPoint); index++; } else { break; } } }
private void codeTemplateCmdEvent_Click(object CommandBarControl, ref bool Handled, ref bool CancelDefault) { CommandBarControl ctrl = CommandBarControl as CommandBarControl; string content = CodeTemplateManager.Instance.GetTemplateContent(ctrl.Caption); int indexOfSelectedParam = CodeTemplateManager.Instance.IndexOfSelectedParam(content); bool surroundSelectedText = (indexOfSelectedParam >= 0); TextSelection selected = _applicationObject.ActiveDocument.Selection as TextSelection; EditPoint topPoint = selected.TopPoint.CreateEditPoint(); EditPoint bottomPoint = selected.BottomPoint.CreateEditPoint(); if (surroundSelectedText) { string beforeSelectedParam = CodeTemplateManager.Instance.GetTextBeforeSelectedParam(content); string afterSelectedParam = CodeTemplateManager.Instance.GetTextAfterSelectedParam(content); topPoint.LineUp(1); topPoint.EndOfLine(); topPoint.Insert(Environment.NewLine); topPoint.Insert(beforeSelectedParam); bottomPoint.EndOfLine(); bottomPoint.Insert(Environment.NewLine); bottomPoint.Insert(afterSelectedParam); } else { topPoint.Delete(bottomPoint); topPoint.Insert(content); } }
/// <summary> /// Adds the property. /// </summary> /// <param name="codeClass">The code class.</param> /// <param name="var">The var.</param> /// <returns></returns> public static CodeProperty AddProperty(CodeClass codeClass, CodeVariable var) { CodeProperty prop = null; try { prop = codeClass.AddProperty( FormatPropertyName(var.Name), FormatPropertyName(var.Name), var.Type.AsFullName, -1, vsCMAccess.vsCMAccessPublic, null); EditPoint editPoint = prop.Getter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); //Delete return default(int); added by codeClass.AddProperty editPoint.Delete(editPoint.LineLength); editPoint.Indent(null, 4); editPoint.Insert(string.Format(CultureInfo.InvariantCulture, "return {0};", var.Name)); editPoint = prop.Setter.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); editPoint.Indent(null, 1); editPoint.Insert(string.Format(CultureInfo.InvariantCulture, "{0} = value;", var.Name)); editPoint.SmartFormat(editPoint); return(prop); } catch { //Property already exists return(null); } }
public void SetContent(string content) { EditPoint start = _document.CreateEditPoint(_document.StartPoint); start.Delete(_document.EndPoint); start.Insert(content); }
/// <summary> /// Performs the style task. /// </summary> /// <param name="projectItem">The project Item</param> /// <param name="ideWindow">The IDE window.</param> protected override void DoWork(ProjectItem projectItem, EnvDTE.Window ideWindow) { if (projectItem.Name.EndsWith(".cs") && !projectItem.Name.EndsWith("Designer.cs")) { Debug.WriteLine("Moving Usings on: " + projectItem.Name); TextDocument objTextDoc = (TextDocument)ideWindow.Document.Object("TextDocument"); EditPoint startPoint = objTextDoc.StartPoint.CreateEditPoint(); string backupText = startPoint.GetText(objTextDoc.EndPoint); try { List <EditPoint> namespaceInsertionPoints = GetInsertionPoints(projectItem.FileCodeModel); if (namespaceInsertionPoints != null && namespaceInsertionPoints.Count > 0) { MoveUsingStatements(projectItem.FileCodeModel, namespaceInsertionPoints); } } catch (Exception exc) { Debug.WriteLine(exc.ToString()); Debug.WriteLine("Attempting to Revert..."); startPoint.Delete(objTextDoc.EndPoint); startPoint.Insert(backupText); Debug.WriteLine("Reverted."); } } }
public sealed override void Undo() { EditPoint ep = _codeMethod.StartPoint.CreateEditPoint(); ep.LineDown(1); ep.Delete(_codeMethod.EndPoint); ep.Insert("{\r\n}"); }
/// <summary> /// Removes the specified range of text. /// </summary> /// <param name="start">Index of removal.</param> /// <param name="count">Count of chars to remove.</param> public void RemoveRange(int start, int count) { EditPoint ep = Document.CreateEditPoint(new LuaTextPoint(Document, 1, start + 1)); for (int i = 0; i < count; i++) { ep.Delete(ep.LineLength + 1); } }
/// <summary> /// add a default constructor. /// </summary> /// <param name="instance">The instance.</param> /// <param name="moveToCorrectPosition">if set to <c>true</c> [move to correct position].</param> /// <returns>The constructor.</returns> public static CodeFunction AddDefaultConstructor( this CodeClass instance, bool moveToCorrectPosition) { TraceService.WriteLine("CodeClassExtensions::AddDefaultConstructor file=" + instance.Name); CodeFunction codeFunction = instance.AddFunction( instance.Name, vsCMFunction.vsCMFunctionConstructor, vsCMTypeRef.vsCMTypeRefVoid, 0, vsCMAccess.vsCMAccessPublic, null); codeFunction.GetEndPoint().CreateEditPoint().InsertNewLine(); string comment = "<doc><summary>\r\nInitializes a new instance of the " + instance.Name + " class.\r\n</summary></doc>\r\n"; codeFunction.DocComment = comment; if (moveToCorrectPosition) { TraceService.WriteLine("Move to correct position"); IEnumerable <CodeVariable> variables = instance.GetVariables(); CodeVariable lastVariable = variables.LastOrDefault(); if (lastVariable != null) { EditPoint startPoint = codeFunction.StartPoint.CreateEditPoint(); EditPoint endPoint = codeFunction.EndPoint.CreateEditPoint(); string text = startPoint.GetText(endPoint); //// remove current code Function text instance.RemoveMember(codeFunction); if (endPoint.GetText(1) == Environment.NewLine) { TraceService.WriteLine("Delete line"); endPoint.Delete(1); } EditPoint editPoint = lastVariable.EndPoint.CreateEditPoint(); editPoint.Insert(string.Format("{0}{1}{2}", Environment.NewLine, Environment.NewLine, text)); //// we need to re find the function as we have deleted this one! codeFunction = instance.GetFunction(instance.Name); codeFunction.DocComment = comment; } } return(codeFunction); }
/// <summary> /// 删除指定位置的文字,从(0,0)开始 /// </summary> /// <param name="startLine"></param> /// <param name="startCol"></param> /// <param name="endLine"></param> /// <param name="endCol"></param> public void DeleteText(int startLine, int startCol, int endLine, int endCol) { EditPoint editPoint = GetEditPoint(startLine, startCol); if (editPoint != null) { object tp; TextLines.CreateTextPoint(endLine, endCol, out tp); editPoint.Delete(tp as TextPoint); } }
private void InsertGeneratedCode(ProjectItem projectItem, string generatedContent) { projectItem.Open(Constants.vsViewKindCode); projectItem.Document.ActiveWindow.Activate(); TextDocument textDocument = (TextDocument)projectItem.Document.Object("TextDocument"); EditPoint editPoint = textDocument.StartPoint.CreateEditPoint(); editPoint.Delete(textDocument.EndPoint); editPoint.Insert(generatedContent); projectItem.Save(Helper.GetFilePath(projectItem)); }
private void EditMigrations(CodeType migration, string updateMethod) { var cc = migration as CodeClass; // get functions var members = cc.Members; // list of ints List <int> migrations = new List <int>(); // iterate through functions foreach (CodeElement member in members) { var func = member as CodeFunction; if (func == null) { continue; } // TODO: investigate use of CodeFunction var createIndex = member.Name == "Create"; if (createIndex) { migrations.Add(0); continue; } var index = member.Name.IndexOf("UpdateFrom"); if (index == -1) { continue; } migrations.Add(Int32.Parse(member.Name.Last().ToString())); } // sort numbers, just in case migrations.Sort(); // get new update number var update = migrations.Count == 0 ? 0 : migrations.Last() + 1; // create method, either update or create var methodName = update == 0 ? "Create" : "UpdateFrom" + update; CodeFunction cf = cc.AddFunction(methodName, vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefInt, -1, vsCMAccess.vsCMAccessPublic); // access new method TextPoint tp = cf.GetStartPoint(vsCMPart.vsCMPartBody); TextPoint end = cf.GetEndPoint(vsCMPart.vsCMPartBody); EditPoint ep = tp.CreateEditPoint(); // delete auto generated code ep.Delete(end); var returnVal = update + 1; ep.Insert(updateMethod + Environment.NewLine + Environment.NewLine + "return " + returnVal + ";"); tp.CreateEditPoint().SmartFormat(ep); }
private static void MakeAutoProperty(CodeProperty2 newProp) { EditPoint setter = newProp.Setter.StartPoint.CreateEditPoint(); setter.Delete(newProp.Setter.EndPoint); setter.Insert("set;"); EditPoint getter = newProp.Getter.StartPoint.CreateEditPoint(); getter.Delete(newProp.Getter.EndPoint); getter.Insert("get;"); }
/// <summary> /// Replaces the code. /// </summary> /// <param name="instance">The instance.</param> /// <param name="newCode">The new code.</param> public static void ReplaceCode( this CodeFunction instance, string newCode) { TraceService.WriteLine("CodeFunctionExtensions::ReplaceCode codeFunction=" + instance.Name); EditPoint startPoint = instance.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); EditPoint endPoint = instance.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); startPoint.Delete(endPoint); startPoint.Insert(newCode); }
/*************************************************************************** * exec */ /** * Retrieves the selected block of text and replaces it with the result of a * call to <c>convertBlock</c>. * * @param sender Command object. ***************************************************************************/ public override void exec(object sender, EventArgs e) { /*----------------------------------------*/ /* Get the document and selection. Indent */ /* offset is current caret position. */ /*----------------------------------------*/ Document doc = app.ActiveDocument; TextSelection select = (TextSelection)doc.Selection; VirtualPoint top = select.TopPoint; VirtualPoint bottom = select.BottomPoint; int indent = select.CurrentColumn - 1; /*--------------------------------------------*/ /* Set edit points at the start and end of */ /* the lines where selection starts and ends. */ /*--------------------------------------------*/ EditPoint ep1 = top.CreateEditPoint(); EditPoint ep2 = bottom.CreateEditPoint(); ep1.MoveToLineAndOffset(top.Line, 1); ep2.MoveToLineAndOffset(bottom.Line, bottom.LineLength + 1); /*---------------------------------------*/ /* Convert the block from the content of */ /* the start and end line of selection. */ /*---------------------------------------*/ string block = convertBlock(ep1.GetText(ep2), indent); if (block != null) { /*------------------------------------*/ /* Open an undo context if none open. */ /*------------------------------------*/ UndoContext undo = app.UndoContext; if (!undo.IsOpen) { undo.Open(GetType().Name, false); } /*----------------------------------------------------------*/ /* Replace the selected block, move the caret to the indent */ /* position on the last line, and close the Undo Context. */ /*----------------------------------------------------------*/ ep1.Delete(ep2); ep1.Insert(block); select.MoveToLineAndOffset(ep1.Line, indent + 1, false); undo.Close(); } }
public void PasteCode(EditPoint objEditPt, string code, PasteOptions pasteOption) { switch (pasteOption) { case PasteOptions.Overwrite: objEditPt.Delete(code.Length); break; case PasteOptions.Append: objEditPt.EndOfDocument(); break; } objEditPt.Insert(code); }
/// <summary> /// Delete the file contents. /// </summary> /// <param name="instance">The instance.</param> public static void DeleteFileContents(this ProjectItem instance) { TraceService.WriteLine("ProjectItemExtensions::DeleteFileContents"); Document document = instance.Document; TextDocument textDoc = (TextDocument)document.Object("TextDocument"); EditPoint editPoint = textDoc.StartPoint.CreateEditPoint(); EditPoint endPoint = textDoc.EndPoint.CreateEditPoint(); editPoint.Delete(endPoint); }
public static void AddStatementsToFunctionBody(this CodeFunction codeFunction, string statements, string className, bool insertAtEnd) { if (string.IsNullOrEmpty(className) || string.IsNullOrEmpty(statements) || (codeFunction == null)) { return; } EditPoint editPoint = codeFunction.StartPoint.CreateEditPoint(); string buff = editPoint.GetText(codeFunction.EndPoint); SyntaxTree tree = CSharpSyntaxTree.ParseText(buff); SyntaxNode root = tree.GetRoot(); if (root == null) { return; } MethodDeclarationSyntax methodDeclaration = root.GetOnModelCreatingParameterName("DbModelBuilder", "ModelBuilder", out string parameterName); if ((methodDeclaration == null) || string.IsNullOrEmpty(parameterName)) { return; } if (methodDeclaration.Body == null) { return; } string strToInsert = //Environment.NewLine + parameterName + ".Entity<" + className + ">()" + statements; if (insertAtEnd) { buff = buff.Insert(methodDeclaration.Body.Span.End - 1, strToInsert); } else { buff = buff.Insert(methodDeclaration.Body.Span.Start + 1, strToInsert); } editPoint = codeFunction.StartPoint.CreateEditPoint(); editPoint.Delete(codeFunction.EndPoint); editPoint.Insert(buff); if (codeFunction.ProjectItem != null) { codeFunction.ProjectItem.Save(); } }
public void ApplyComposer(TextDocument document, ComposerStrings composer) { /* get document bounds */ EditPoint startEdit = document.CreateEditPoint(document.StartPoint); EditPoint endEdit = document.EndPoint.CreateEditPoint(); /* run composer */ string text = startEdit.GetText(document.EndPoint); composer.Compose(text); if (composer.EnumModels != null && composer.EnumModels.Count > 0) { /* get new file*/ text = composer.GetResultFile(); /* delete and re-insert full document */ startEdit.Delete(endEdit); startEdit.Insert(text); } }
protected void AddOneLineImpl(string NewLine, CodeFunction Target, bool ReplaceExisingLine) { //Target.GetEndPoint(EnvDTE.vsCMPart.vsCMPartBody); EditPoint startOfLastLine = Target.GetEndPoint(EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter).CreateEditPoint(); startOfLastLine.LineUp(1); startOfLastLine.StartOfLine(); EditPoint endOfLastLine = Target.GetEndPoint(EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter).CreateEditPoint(); endOfLastLine.LineUp(1); endOfLastLine.EndOfLine(); if (ReplaceExisingLine) { startOfLastLine.Delete(endOfLastLine); } else { startOfLastLine.EndOfLine(); } startOfLastLine.Insert(NewLine); }
/// <summary> /// Moves using statements to a given set of insertion points. /// </summary> /// <param name="fileCodeModel">The code model to search.</param> /// <param name="insertionPoints">The insertion points to use.</param> private void MoveUsingStatements(FileCodeModel fileCodeModel, List <EditPoint> insertionPoints) { List <string> usingStatements = new List <string>(); for (int i = 1; i <= fileCodeModel.CodeElements.Count; i++) { CodeElement element = fileCodeModel.CodeElements.Item(i); if (element.Kind == vsCMElement.vsCMElementImportStmt) { EditPoint usingStart = element.StartPoint.CreateEditPoint(); string statement = usingStart.GetText(element.EndPoint); usingStatements.Add(statement); usingStart.Delete(element.EndPoint); usingStart.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical); i--; } } for (int i = 0; i < insertionPoints.Count; i++) { EditPoint origin = insertionPoints[i].CreateEditPoint(); if (usingStatements.Count > 0) { origin.Insert("\r\n"); for (int j = 0; j < usingStatements.Count; j++) { origin.Insert(usingStatements[j] + "\r\n"); } } origin.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical); if (usingStatements.Count > 0) { origin.Insert("\r\n"); } } }
private void DoExpand(TextSelection selection) { if (_delegateStart == null) { return; } var point = selection.BottomPoint.CreateEditPoint(); point.EndOfLine(); var point2 = selection.BottomPoint.CreateEditPoint(); string line = point2.GetText(point); if (line.Trim() == "throw new NotImplementedException();") { var delPoint = _delegateStart.CreateEditPoint(); delPoint.GetText(-1); delPoint.WordLeft(3); delPoint.Delete(_delegateStart); _delegateStart.WordRight(); _delegateStart.Delete(1); } _delegateStart = null; }
protected bool AddSynchWrapperMember(CodeClass synch, CodeFunction cf) { if (cf != null && (cf.FunctionKind & FunctionsThatCantBeAnnotatedAsVirtual) == 0 && cf.CanOverride == true && cf.IsShared == false) { //add prototype and parameters CodeFunction synchFunction = synch.AddFunction(cf.Name, cf.FunctionKind, cf.Type, -1, cf.Access, null); foreach (CodeParameter param in cf.Parameters) { synchFunction.AddParameter(param.Name, param.Type, -1); } synchFunction.CanOverride = true; EditPoint replaceVirtual = synchFunction.StartPoint.CreateEditPoint(); TextRanges tr = null; replaceVirtual.ReplacePattern(synchFunction.EndPoint, "virtual", "override", (int)EnvDTE.vsFindOptions.vsFindOptionsMatchWholeWord, ref tr); //remove default return EditPoint editPt = synchFunction.EndPoint.CreateEditPoint(); editPt.LineUp(1); editPt.StartOfLine(); string returnType = cf.Type.AsString; if (returnType != "void") { EditPoint startOfLastLine = synchFunction.EndPoint.CreateEditPoint(); startOfLastLine.LineUp(1); startOfLastLine.EndOfLine(); editPt.Delete(startOfLastLine); } //generate method body System.Text.StringBuilder methodBody = new System.Text.StringBuilder(100); if (returnType != "void") { methodBody.Append(cf.Type.AsString + " ret;\n"); } methodBody.Append( "System.Threading.Monitor.Enter(_root);" + "\ntry{"); if (returnType != "void") { methodBody.Append("\nret = _parent." + cf.Name + "("); } else { methodBody.Append("\n_parent." + cf.Name + "("); } bool first = true; foreach (CodeParameter p in cf.Parameters) { if (!first) { methodBody.Append(", "); } first = false; int typeSpaceLocation = p.Type.AsString.IndexOf(' '); if (typeSpaceLocation != -1) //append out or ref to parameter { methodBody.Append(p.Type.AsString.Substring(0, typeSpaceLocation + 1)); } methodBody.Append(p.Name); } methodBody.Append(");"); methodBody.Append( "\n}" + "\nfinally{System.Threading.Monitor.Exit(_root);}"); if (returnType != "void") { methodBody.Append("\nreturn ret;"); } //add new body to method editPt.Insert(methodBody.ToString()); editPt.MoveToPoint(synchFunction.StartPoint); editPt.SmartFormat(synchFunction.EndPoint); } return(true); }
public static bool DeleteCodeSite(this CodeFunction value, bool bDelete = true) { if (bDelete && !value.ExistsCodeSite()) { return(true); } EditPoint epStart = value.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); EditPoint epEnd = value.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); EditPoint epFind = null, epFindStart = null; bool Find(string text, bool start) { string[] textSplit; if (start) { epFind = epStart.CreateEditPoint(); textSplit = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); } else { epFind = epEnd.CreateEditPoint(); textSplit = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Reverse().ToArray(); } int iLine = 0; foreach (var item in textSplit) { int i = item.IndexOfAny(new char[] { '(', ' ' }); string s = i == -1 ? item : item.Substring(0, i + 1); if ((start ? epFind.FindPattern(s) : epFind.FindPattern(s, (int)vsFindOptions.vsFindOptionsBackwards)) && (start ? epFind.LessThan(epEnd) : epFind.GreaterThan(epStart)) && (iLine == 0 || iLine == epFind.Line - (start ? 1 : -1))) { if (iLine == 0) { epFindStart = epFind.CreateEditPoint(); } iLine = epFind.Line; if (start) { epFind.EndOfLine(); } } else { return(false); } } return(true); } void Delete() { if (epFind.GreaterThan(epFindStart)) { epFind.LineDown(1); } else { epFindStart.LineDown(1); } epFind.StartOfLine(); epFindStart.StartOfLine(); epFindStart.Delete(epFind); } if (!Find(value.CSEnterText(), true)) { return(false); } else if (bDelete) { Delete(); } if (!Find(value.CSExitText(), false)) { return(false); } else if (bDelete) { Delete(); } else { return(true); } if (Find(value.CSCatchText(), false) && bDelete) { Delete(); } //格式化指定范围内的文本 value.StartPoint.CreateEditPoint().SmartFormat(value.EndPoint); return(true); }
public static void DoRemoveInvocationWithFilter(this CodeFunction codeFunction, string[] classNames, List <FluentAPIEntityNode> filter) { if (classNames == null) { return; } if (codeFunction == null) { return; } EditPoint editPoint = codeFunction.StartPoint.CreateEditPoint(); editPoint.SmartFormat(codeFunction.EndPoint); editPoint = codeFunction.StartPoint.CreateEditPoint(); string buff = editPoint.GetText(codeFunction.EndPoint); SyntaxTree tree = CSharpSyntaxTree.ParseText(buff); SyntaxNode root = tree.GetRoot(); if (root == null) { return; } MethodDeclarationSyntax methodDeclaration = root.GetOnModelCreatingParameterName("DbModelBuilder", "ModelBuilder", out string parameterName); if ((methodDeclaration == null) || string.IsNullOrEmpty(parameterName)) { return; } if (methodDeclaration.Body == null) { return; } List <TextSpan> spans = new List <TextSpan>(); foreach (StatementSyntax ss in methodDeclaration.Body.Statements) { if (ss.Kind() != SyntaxKind.ExpressionStatement) { continue; } ExpressionStatementSyntax expressionStatementSyntax = ss as ExpressionStatementSyntax; if (expressionStatementSyntax.Expression == null) { continue; } if (expressionStatementSyntax.Expression.Kind() != SyntaxKind.InvocationExpression) { continue; } InvocationExpressionSyntax invocationExpressionSyntax = expressionStatementSyntax.Expression as InvocationExpressionSyntax; if (!parameterName.Equals(invocationExpressionSyntax.InvocationExpressionRootName(classNames))) { continue; } FluentAPIEntityNode faen = expressionStatementSyntax.Expression.InvocationExpressionMethods(null); if (faen == null) { continue; } if (faen.Methods == null) { continue; } if (faen.IsSatisfiedTheFilter(filter)) { spans.Insert(0, expressionStatementSyntax.Span); } } foreach (TextSpan ts in spans) { buff = buff.Remove(ts.Start, ts.Length); // // the commented code does not work : ts.Start does not correctly point to begining of the operator //editPoint.CharRight(ts.Start); //editPoint.Delete(ts.Length); //editPoint.CharLeft(ts.Start); //if (codeFunction.ProjectItem != null) //{ // codeFunction.ProjectItem.Save(); //} } buff = buff.Replace(Environment.NewLine + Environment.NewLine, Environment.NewLine); editPoint = codeFunction.StartPoint.CreateEditPoint(); editPoint.Delete(codeFunction.EndPoint); editPoint.Insert(buff); if (codeFunction.ProjectItem != null) { codeFunction.ProjectItem.Save(); } }
private void EditMigrations(Dictionary <string, string> properties) { // Edit migrations var migration = _viewModel.SelectedMigration.CodeType; var cc = migration as CodeClass; // get functions var members = cc.Members; // list of ints List <int> migrations = new List <int>(); // iterate through functions foreach (CodeElement member in members) { var func = member as CodeFunction; if (func == null) { continue; } // TODO: investigate use of CodeFunction var createIndex = member.Name == "Create"; if (createIndex) { migrations.Add(0); continue; } var index = member.Name.IndexOf("UpdateFrom"); if (index == -1) { continue; } migrations.Add(Int32.Parse(member.Name.Last().ToString())); } // sort numbers, just in case migrations.Sort(); // get new update number var update = migrations.Count == 0 ? 0 : migrations.Last() + 1; // create method, either update or create var methodName = update == 0 ? "Create" : "UpdateFrom" + update; CodeFunction cf = cc.AddFunction(methodName, vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefInt, -1, vsCMAccess.vsCMAccessPublic); // access new method TextPoint tp = cf.GetStartPoint(vsCMPart.vsCMPartBody); TextPoint end = cf.GetEndPoint(vsCMPart.vsCMPartBody); EditPoint ep = tp.CreateEditPoint(); // delete auto generated code ep.Delete(end); var partName = _viewModel.PartName.Trim(); // add part bits and bobs if (_viewModel.Attachable) { ep.Insert(String.Format(@"ContentDefinitionManager.AlterPartDefinition(""{0}"", builder => builder", partName) + Environment.NewLine); // make attachable ep.Insert(".Attachable()"); // add description if (!String.IsNullOrEmpty(_viewModel.HelpText)) { ep.Insert(Environment.NewLine + @".WithDescription(""" + _viewModel.HelpText + @""")"); } ep.Insert(");" + Environment.NewLine + Environment.NewLine); } // add record migration if (_viewModel.Storage.Contains("Record Storage")) { ep.Insert(String.Format(@"SchemaBuilder.CreateTable(""{0}Record"", table => table", partName) + Environment.NewLine + ".ContentPartRecord()"); foreach (var prop in properties) { ep.Insert(Environment.NewLine + ".Column<" + prop.Value + @">(""" + prop.Key + @""")"); } ep.Insert(");" + Environment.NewLine + Environment.NewLine); } // create widget if (_viewModel.CreateWidget) { ep.Insert(String.Format(@"ContentDefinitionManager.AlterTypeDefinition(""{0}"", widget => widget", (_viewModel.WidgetName ?? partName + "Widget").Trim()) + Environment.NewLine + @".WithPart(""CommonPart"")" + Environment.NewLine + @".WithPart(""WidgetPart"")" + Environment.NewLine + @".WithPart(""" + partName + @""")" + Environment.NewLine + @".WithSetting(""Stereotype"", ""Widget"")" ); ep.Insert(");" + Environment.NewLine + Environment.NewLine); } var returnVal = update + 1; ep.Insert(string.Format("return {0};", returnVal)); // format document tp.CreateEditPoint().SmartFormat(ep); }
/// <summary> /// Help method to modify KeyinCommands.cs or KeyinCommands.vb. /// </summary> /// <param name="projectItem"></param> /// <param name="keyinCommandFunctionCS"></param> /// <param name="keyinCommandFunctionvb"></param> private void ModifyKeyinsCommands(ProjectItem projectItem, string keyinCommandFunctionCS, string keyinCommandFunctionvb, string keyinCommandFunctionCPP) { Document activeDoc = projectItem.Document; if (activeDoc == null) { return; } ProjectItem activeDocumentProjectItem = activeDoc.ProjectItem; if (activeDocumentProjectItem == null) { return; } FileCodeModel fileCodeModel = activeDocumentProjectItem.FileCodeModel; if (fileCodeModel == null) { return; } CodeElements codeElements = fileCodeModel.CodeElements; CodeClass codeClass = null; // look for the namespace in the active document CodeNamespace codeNamespace = null; foreach (CodeElement codeElement in codeElements) { if (codeElement.Kind == vsCMElement.vsCMElementNamespace) { codeNamespace = codeElement as CodeNamespace; break; } } if (codeNamespace == null) { if (IsVBProject) { codeElements = fileCodeModel.CodeElements; } else { return; } } else { codeElements = codeNamespace.Members; } if (codeElements == null) { return; } // look for the first class foreach (CodeElement codeElement in codeElements) { if (codeElement.Kind == vsCMElement.vsCMElementClass) { codeClass = codeElement as CodeClass; break; } } if (codeClass == null) { return; } if (IsCSProject) { CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic); codeFunction.AddParameter("unparsed", vsCMTypeRef.vsCMTypeRefString, -1); TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = textPoint.CreateEditPoint(); EditPoint objMovePt = textPoint.CreateEditPoint(); EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint(); UtilEditPoint.ReplaceText(6, "public static", 0); editPoint.Insert ( keyinCommandFunctionCS ); editPoint.StartOfDocument(); objMovePt.EndOfDocument(); editPoint.SmartFormat(objMovePt); } else if (IsVBProject) { CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionSub, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic); codeFunction.AddParameter("unparsed", vsCMTypeRef.vsCMTypeRefString, -1); TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = textPoint.CreateEditPoint(); EditPoint objMovePt = textPoint.CreateEditPoint(); EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint(); UtilEditPoint.ReplaceText(6, "Public Shared", 0); editPoint.Insert ( keyinCommandFunctionvb ); editPoint.StartOfDocument(); objMovePt.EndOfDocument(); editPoint.SmartFormat(objMovePt); } else if (IsVCProject) { TextDocument editDoc = (TextDocument)activeDoc.Object("TextDocument"); EditPoint objEditPt = editDoc.CreateEditPoint(); EditPoint objMovePt = editDoc.EndPoint.CreateEditPoint(); objEditPt.StartOfDocument(); activeDoc.ReadOnly = false; if (objEditPt.FindPattern("#include")) { objEditPt.LineDown(1); objEditPt.Insert("#include \"" + FunctionName + ".h\"\n"); } else if ((objEditPt.FindPattern("#using"))) { objEditPt.LineUp(1); objEditPt.Insert("#include \"" + FunctionName + ".h\"\n"); } else { objEditPt.FindPattern("namespace"); objEditPt.LineUp(1); objEditPt.Insert("#include \"" + FunctionName + ".h\"\n"); } CodeFunction codeFunction = codeClass.AddFunction(FunctionName + "Keyin", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic); codeFunction.AddParameter("unparsed", "System::String^", -1); TextPoint textPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartBody); EditPoint editPoint = textPoint.CreateEditPoint(); objMovePt = textPoint.CreateEditPoint(); EditPoint UtilEditPoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint(); UtilEditPoint.ReplaceText(4, "public:static", 0); editPoint.Insert(keyinCommandFunctionCPP); if (objEditPt.FindPattern("throw gcnew System::NotImplementedException();")) { editPoint.Delete(52); } editPoint.StartOfDocument(); objMovePt.EndOfDocument(); editPoint.SmartFormat(objMovePt); } }
/// <summary> /// Performs the style task. /// </summary> /// <param name="projectItem">The project Item</param> /// <param name="ideWindow">The IDE window.</param> protected override void DoWork(ProjectItem projectItem, EnvDTE.Window ideWindow) { if (projectItem.Name.EndsWith(".cs")) { Debug.WriteLine("Formatting Spacing Around Comments: " + projectItem.Name); try { TextDocument objTextDoc = (TextDocument)ideWindow.Document.Object("TextDocument"); EditPoint objEditPoint = objTextDoc.CreateEditPoint(objTextDoc.StartPoint); EditPoint commentPoint = objEditPoint.CreateEditPoint(); TextRanges trs = null; while (objEditPoint.FindPattern("//", (int)vsFindOptions.vsFindOptionsMatchCase, ref commentPoint, ref trs)) { bool previousBlank = false; bool isNotInline = true; EditPoint beginningLineEditPoint = objEditPoint.CreateEditPoint(); beginningLineEditPoint.StartOfLine(); if (beginningLineEditPoint.GetText(objEditPoint).Trim() != string.Empty) { isNotInline = false; } if (isNotInline) { EditPoint previousCheckPoint = objEditPoint.CreateEditPoint(); previousCheckPoint.LineUp(1); if (previousCheckPoint.GetText(objEditPoint).Trim() == string.Empty) { previousBlank = true; } commentPoint.CharRight(1); string comment = objEditPoint.GetText(commentPoint); while (!comment.EndsWith(" ") && !commentPoint.AtEndOfLine) { if (comment.EndsWith("/")) { commentPoint.CharRight(1); } else { commentPoint.CharLeft(1); commentPoint.Insert(" "); } comment = objEditPoint.GetText(commentPoint); } commentPoint.CharRight(1); comment = objEditPoint.GetText(commentPoint); if (comment.EndsWith(" ")) { commentPoint.CharLeft(1); commentPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsHorizontal); commentPoint.Insert(" "); } if (commentPoint.Line > objEditPoint.Line) { commentPoint.LineUp(1); commentPoint.EndOfLine(); } if (commentPoint.AtEndOfLine) { objEditPoint.Delete(commentPoint); } else { EditPoint endComment = commentPoint.CreateEditPoint(); endComment.EndOfLine(); if (commentPoint.GetText(endComment).Trim() == string.Empty) { objEditPoint.Delete(endComment); } else { objEditPoint.LineDown(1); previousBlank = false; } } objEditPoint.StartOfLine(); commentPoint = objEditPoint.CreateEditPoint(); commentPoint.EndOfLine(); if (objEditPoint.GetText(commentPoint).Trim() == string.Empty) { objEditPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical); if (previousBlank) { objEditPoint.Insert("\r\n"); } } } objEditPoint.EndOfLine(); } } catch (Exception exc) { Debug.WriteLine(exc.ToString()); Debug.WriteLine("Formatting Spacing Around Comments failed, skipping"); } } }
/// <summary> /// Updates the #endregion directives to match the names of the matching #region directive /// and cleans up any unnecessary white space. /// </summary> /// <remarks> /// This code is very similar to the Common region retrieval function, but since it /// manipulates the cursors during processing the logic is different enough to warrant a /// separate copy of the code. /// </remarks> /// <param name="textDocument">The text document to cleanup.</param> internal void UpdateEndRegionDirectives(TextDocument textDocument) { if (!Settings.Default.Cleaning_UpdateEndRegionDirectives) { return; } var regionStack = new Stack <string>(); EditPoint cursor = textDocument.StartPoint.CreateEditPoint(); TextRanges subGroupMatches = null; // Not used - required for FindPattern. const string pattern = @"^[ \t]*#"; // Keep pushing cursor forwards (note ref cursor parameter) until finished. while (cursor != null && cursor.FindPattern(pattern, TextDocumentHelper.StandardFindOptions, ref cursor, ref subGroupMatches)) { // Create a pointer to capture the text for this line. EditPoint eolCursor = cursor.CreateEditPoint(); eolCursor.EndOfLine(); string regionText = cursor.GetText(eolCursor); if (regionText.StartsWith("region ")) // Space required by compiler. { // Cleanup any whitespace in the region name. string regionName = regionText.Substring(7); string regionNameTrimmed = regionName.Trim(); if (regionName != regionNameTrimmed) { cursor.CharRight(7); cursor.Delete(eolCursor); cursor.Insert(regionNameTrimmed); } // Push the parsed region name onto the top of the stack. regionStack.Push(regionNameTrimmed); } else if (regionText.StartsWith("endregion")) // Space may or may not be present. { if (regionStack.Count > 0) { // Do not trim the endRegionName in order to catch whitespace differences. string endRegionName = regionText.Length > 9 ? regionText.Substring(10) : String.Empty; string matchingRegion = regionStack.Pop(); // Update if the strings do not match. if (matchingRegion != endRegionName) { cursor.CharRight(9); cursor.Delete(eolCursor); cursor.Insert(" " + matchingRegion); } } else { // This document is improperly formatted, abort. return; } } // Note: eolCursor may be outdated now if changes have been made. cursor.EndOfLine(); } }
/// <summary> /// Sorts functions within a class. /// </summary> /// <param name="codeElement">The code element that represents the class.</param> private void SortFunctionsWithinClass(CodeElement codeElement) { EditPoint classPoint = codeElement.StartPoint.CreateEditPoint(); TextRanges trs = null; string classBackup = classPoint.GetText(codeElement.EndPoint); try { if (classPoint.FindPattern("{", (int)vsFindOptions.vsFindOptionsMatchCase, ref classPoint, ref trs)) { classPoint.Insert("\r\n"); List <CodeBlock> blocks = new List <CodeBlock>(); Array accessLevels = Enum.GetValues(typeof(vsCMAccess)); for (int i = 1; i <= codeElement.Children.Count; i++) { CodeElement element = codeElement.Children.Item(i); if (element.Kind != vsCMElement.vsCMElementAttribute) { EditPoint startBlock = element.GetStartPoint(vsCMPart.vsCMPartWholeWithAttributes).CreateEditPoint(); EditPoint newStartPoint = startBlock.CreateEditPoint(); CodeBlock block = EvaluateBlock(codeElement, element, ref newStartPoint); if (block != null) { blocks.Add(block); newStartPoint.Delete(element.EndPoint); newStartPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical); i--; } } } blocks.Sort(delegate(CodeBlock c1, CodeBlock c2) { int comparison = 0; if (c1.Placement != c2.Placement) { comparison = c1.Placement.CompareTo(c2.Placement); } else if (c1.Access != c2.Access) { comparison = c1.Access.CompareTo(c2.Access); } else if (c1.Name != c2.Name) { comparison = c1.Name.CompareTo(c2.Name); } else { comparison = c1.Weight.CompareTo(c2.Weight); } return(comparison); }); classPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical); classPoint.Insert("\r\n"); for (int i = 0; i < blocks.Count; i++) { classPoint.Insert(blocks[i].Body + "\r\n\r\n"); } classPoint.LineUp(1); classPoint.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical); for (int i = 1; i <= codeElement.Children.Count; i++) { CodeElement element = codeElement.Children.Item(i); if (element.Kind == vsCMElement.vsCMElementClass || element.Kind == vsCMElement.vsCMElementInterface || element.Kind == vsCMElement.vsCMElementStruct) { SortFunctionsWithinClass(element); } } } } catch (Exception exc) { Debug.WriteLine(exc.ToString()); EditPoint startBackup = codeElement.StartPoint.CreateEditPoint(); startBackup.Delete(codeElement.EndPoint); startBackup.Insert(classBackup); Debug.WriteLine("-- Class Reverted --"); } }