private void adjustWhiteSpace()
{
ThreadHelper.JoinableTaskFactory.Run(async delegate
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var editSession = _buffer.CreateEdit();
var changed = false;
try
{
var snapshot = editSession.Snapshot;
if (_settings.InsertFinalNewline)
{
var text = snapshot.GetText();
if (!text.EndsWith(Environment.NewLine))
{
var line = snapshot.GetLineFromLineNumber(snapshot.LineCount - 1);
editSession.Insert(line.End.Position, Environment.NewLine);
changed = true;
}
}
if (_settings.TrimTrailingWhiteSpace)
{
foreach (var line in snapshot.Lines)
{
var text = line.GetText();
if (text.Length > 0)
{
var last = text[text.Length - 1];
if (last == ' ' || last == '\t')
{
text = text.TrimEnd();
editSession.Replace(line.Start.Position, line.Length, text);
changed = true;
}
}
}
}
}
catch (Exception)
{
editSession.Cancel();
}
finally
{
if (changed)
{
editSession.Apply();
}
else
{
editSession.Cancel();
}
}
});
}
public static void MakeEmptyEdit(this ITextBuffer textBuffer)
{
var bufferLength = textBuffer.CurrentSnapshot.Length;
using var edit = textBuffer.CreateEdit(EditOptions.None, reiteratedVersionNumber: null, InviolableEditTag.Instance);
edit.Insert(bufferLength, " ");
edit.Apply();
using var revertEdit = textBuffer.CreateEdit(EditOptions.None, reiteratedVersionNumber: null, InviolableEditTag.Instance);
revertEdit.Delete(bufferLength, 1);
revertEdit.Apply();
}
public void Do()
{
if (!CanRedo)
{
throw new InvalidOperationException();
}
using (var ed = textBuffer.CreateEdit(EditOptions.None, info.AfterVersionNumber, editTag)) {
foreach (var change in info.Collection)
{
ed.Replace(change.OldSpan, change.NewText);
}
ed.Apply();
}
canUndo = true;
}
/// Takes current text buffer and new text then builds list of changed
/// regions and applies them to the buffer. This way we can avoid
/// destruction of bookmarks and other markers. Complete
/// buffer replacement deletes all markers which causes
/// loss of bookmarks, breakpoints and other similar markers.
public static void ApplyChange(
ITextBuffer textBuffer,
int position,
int length,
string newText,
string transactionName,
ISelectionTracker selectionTracker,
int maxMilliseconds) {
var snapshot = textBuffer.CurrentSnapshot;
int oldLength = Math.Min(length, snapshot.Length - position);
string oldText = snapshot.GetText(position, oldLength);
var changes = TextChanges.BuildChangeList(oldText, newText, maxMilliseconds);
if (changes != null && changes.Count > 0) {
using (var selectionUndo = new SelectionUndo(selectionTracker, transactionName, automaticTracking: false)) {
using (ITextEdit edit = textBuffer.CreateEdit()) {
// Replace ranges in reverse so relative positions match
for (int i = changes.Count - 1; i >= 0; i--) {
TextChange tc = changes[i];
edit.Replace(tc.Position + position, tc.Length, tc.NewText);
}
edit.Apply();
}
}
}
}
public bool ReplaceAll(ITextBuffer tb)
{
Contract.Assume(tb != null);
var tra = new TacticReplacerActor(tb);
var isMoreMembers = tra.NextMemberInTld();
var replaceStatus = TacticReplaceStatus.Success;
var tedit = tb.CreateEdit();
try
{
while (isMoreMembers && (replaceStatus == TacticReplaceStatus.Success || replaceStatus == TacticReplaceStatus.NoTactic))
{
var isMoreTactics = tra.NextTacticCallInMember();
while (isMoreTactics && (replaceStatus == TacticReplaceStatus.Success || replaceStatus == TacticReplaceStatus.NoTactic))
{
replaceStatus = tra.ReplaceSingleTacticCall(tedit);
isMoreTactics = tra.NextTacticCallInMember();
}
isMoreMembers = tra.NextMemberInTld();
}
if (replaceStatus == TacticReplaceStatus.Success || replaceStatus == TacticReplaceStatus.NoTactic)
{
tedit.Apply();
}
else
{
tedit.Dispose();
}
} catch { tedit.Dispose(); }
return(NotifyOfReplacement(replaceStatus));
}
private void UpdateFromImport(PythonAst curAst, FromImportStatement fromImport)
{
NameExpression[] names = new NameExpression[fromImport.Names.Count + 1];
NameExpression[] asNames = fromImport.AsNames == null ? null : new NameExpression[fromImport.AsNames.Count + 1];
NameExpression newName = new NameExpression(Name);
for (int i = 0; i < fromImport.Names.Count; i++)
{
names[i] = fromImport.Names[i];
}
names[fromImport.Names.Count] = newName;
if (asNames != null)
{
for (int i = 0; i < fromImport.AsNames.Count; i++)
{
asNames[i] = fromImport.AsNames[i];
}
}
var newImport = new FromImportStatement((ModuleName)fromImport.Root, names, asNames, fromImport.IsFromFuture, fromImport.ForceAbsolute);
curAst.CopyAttributes(fromImport, newImport);
var newCode = newImport.ToCodeString(curAst);
var span = fromImport.GetSpan(curAst);
int leadingWhiteSpaceLength = (fromImport.GetLeadingWhiteSpace(curAst) ?? "").Length;
using (var edit = _buffer.CreateEdit()) {
edit.Delete(span.Start.Index - leadingWhiteSpaceLength, span.Length + leadingWhiteSpaceLength);
edit.Insert(span.Start.Index, newCode);
edit.Apply();
}
}
protected void ApplyReplacementText(ITextBuffer subjectBuffer, ITextUndoHistory undoHistory, object propagateSpansEditTag, IEnumerable <ITrackingSpan> spans, string replacementText)
{
// roll back to the initial state for the buffer after conflict resolution
this.UndoTemporaryEdits(subjectBuffer, disconnect: false, undoConflictResolution: replacementText == string.Empty);
using var transaction = undoHistory.CreateTransaction(GetUndoTransactionDescription(replacementText));
using var edit = subjectBuffer.CreateEdit(EditOptions.None, null, propagateSpansEditTag);
foreach (var span in spans)
{
if (span.GetText(subjectBuffer.CurrentSnapshot) != replacementText)
{
edit.Replace(span.GetSpan(subjectBuffer.CurrentSnapshot), replacementText);
}
}
edit.ApplyAndLogExceptions();
if (!edit.HasEffectiveChanges && !this.UndoStack.Any())
{
transaction.Cancel();
}
else
{
transaction.Complete();
}
}
/// <summary>
/// Normalizes the given buffer to match the given newline string on every line
/// </summary>
/// <returns>True if the buffer was changed. False otherwise.</returns>
public static bool NormalizeNewlines(this ITextBuffer buffer, string newlineString)
{
using (var edit = buffer.CreateEdit())
{
foreach (var line in edit.Snapshot.Lines)
{
if (line.LineBreakLength != 0)
{
// Calling line.GetLineBreakText allocates a string. Since we only have 1 2-character newline to worry about
// we can do this without that allocation by comparing characters directly.
if (line.LineBreakLength != newlineString.Length || edit.Snapshot[line.End] != newlineString[0])
{
// Intentionally ignore failed replaces. We'll do the best effort change here.
edit.Replace(new Span(line.End, line.LineBreakLength), newlineString);
}
}
}
if (edit.HasEffectiveChanges)
{
return(edit.Apply() != edit.Snapshot);
}
else
{
// We didn't have to do anything
return(false);
}
}
}
private ITextEdit FixByMoving(RobotsTxtLineSyntax line, RobotsTxtRecordSyntax record)
{
ITextBuffer buffer = line.Record.Document.Snapshot.TextBuffer;
// default insertion point at record start
SnapshotPoint insertionPoint = record.Span.Start;
// find last User-agent line
var last = record.Lines
.TakeWhile(l => l.NameToken.Value.Equals("User-agent", StringComparison.InvariantCultureIgnoreCase))
.LastOrDefault();
if (last != null) // override insertion point
{
insertionPoint = last.Span.End.GetContainingLine().EndIncludingLineBreak;
}
// move line up
ITextEdit edit = buffer.CreateEdit();
edit.Insert(
insertionPoint,
line.Span.Start.GetContainingLine().GetTextIncludingLineBreak()
);
edit.Delete(line.Span.Start.GetContainingLine().ExtentIncludingLineBreak);
return(edit);
}
public bool Replace()
{
if (SearchTerm == null)
{
throw new InvalidOperationException();
}
if (SearchTerm.Length == 0)
{
throw new InvalidOperationException();
}
if (CurrentResult == null)
{
throw new InvalidOperationException();
}
if (ReplaceTerm == null)
{
throw new InvalidOperationException();
}
var spanToUse = searchSpan?.GetSpan(CurrentResult.Value.Snapshot) ?? new SnapshotSpan(CurrentResult.Value.Snapshot, 0, CurrentResult.Value.Snapshot.Length);
SnapshotSpan searchRange;
if ((SearchOptions & FindOptions.SearchReverse) != 0)
{
Debug.Assert(spanToUse.Start <= CurrentResult.Value.End);
if (spanToUse.Start > CurrentResult.Value.End)
{
return(false);
}
searchRange = new SnapshotSpan(spanToUse.Start, CurrentResult.Value.End);
}
else
{
Debug.Assert(CurrentResult.Value.Start <= spanToUse.End);
if (CurrentResult.Value.Start > spanToUse.End)
{
return(false);
}
searchRange = new SnapshotSpan(CurrentResult.Value.Start, spanToUse.End);
}
string expandedReplacePattern;
var span = textSearchService2.FindForReplace(searchRange, SearchTerm, ReplaceTerm, SearchOptions, out expandedReplacePattern);
if (span == null)
{
return(false);
}
using (var ed = buffer.CreateEdit()) {
var currSpan = span.Value.TranslateTo(buffer.CurrentSnapshot, SpanTrackingMode.EdgeInclusive);
if (!ed.Replace(currSpan.Span, expandedReplacePattern))
{
return(false);
}
ed.Apply();
// Don't check the snapshot returned by Apply() since we could've replaced a 0-length span with the
// empty string if regex search was used. In that case, no new snapshot is created.
return(!ed.Canceled);
}
}
private static void UpdateText(
ImmutableArray <TextChange> textChanges,
ITextBuffer buffer,
ITextSnapshot oldSnapshot,
SourceText oldText,
EditOptions options
)
{
using var edit = buffer.CreateEdit(
options,
reiteratedVersionNumber: null,
editTag: null
);
if (CodeAnalysis.Workspace.TryGetWorkspace(oldText.Container, out var workspace))
{
var undoService = workspace.Services.GetRequiredService <ISourceTextUndoService>();
undoService.BeginUndoTransaction(oldSnapshot);
}
foreach (var change in textChanges)
{
edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
}
edit.ApplyAndLogExceptions();
}
static void Insert(IAsyncCompletionSession session, ITextBuffer buffer, string text, SnapshotSpan span)
{
var bufferEdit = buffer.CreateEdit();
bufferEdit.Replace(span, text);
bufferEdit.Apply();
}
private static void MinimizeBuffers(ITextBuffer leftBuffer, ITextBuffer rightBuffer, ITextSnapshot startingVersion, int minPos, int maxPos)
{
// Remove the unchanged content from both buffers
using (var edit = leftBuffer.CreateEdit()) {
edit.Delete(0, minPos);
edit.Delete(Span.FromBounds(maxPos, startingVersion.Length));
edit.Apply();
}
using (var edit = rightBuffer.CreateEdit()) {
edit.Delete(
0,
Tracking.TrackPositionForwardInTime(
PointTrackingMode.Negative,
minPos,
startingVersion.Version,
rightBuffer.CurrentSnapshot.Version
)
);
edit.Delete(
Span.FromBounds(
Tracking.TrackPositionForwardInTime(
PointTrackingMode.Positive,
maxPos,
startingVersion.Version,
rightBuffer.CurrentSnapshot.Version
),
rightBuffer.CurrentSnapshot.Length
)
);
edit.Apply();
}
}
public static void SetTextContent(this ITextBuffer textBuffer, string textContent)
{
var edit = textBuffer.CreateEdit(EditOptions.DefaultMinimalChange, 0, null);
edit.Replace(new Span(0, textBuffer.CurrentSnapshot.Length), textContent);
edit.Apply();
}
public void OnCharTyped(char @char)
{
// format on ':'
if (@char == RobotsTxtSyntaxFacts.NameValueDelimiter)
{
ITextBuffer buffer = _textView.TextBuffer;
SyntaxTree syntaxTree = buffer.GetSyntaxTree();
RobotsTxtDocumentSyntax root = syntaxTree.Root as RobotsTxtDocumentSyntax;
// find in syntax tree
var caret = _textView.Caret.Position.BufferPosition;
RobotsTxtLineSyntax lineSyntax = root.Records
.SelectMany(r => r.Lines)
.FirstOrDefault(p => p.DelimiterToken.Span.Span.End == caret);
if (lineSyntax != null)
{
using (ITextUndoTransaction transaction = _undoHistory.CreateTransaction("Automatic Formatting"))
{
using (ITextEdit edit = buffer.CreateEdit())
{
// fix indent
// find property before
RobotsTxtLineSyntax before = lineSyntax.Record.Lines
.TakeWhile(p => p != lineSyntax)
.LastOrDefault();
// reference point
if (before != null)
{
SnapshotPoint referencePoint = before.NameToken.Span.Span.Start;
// compare
ITextSnapshotLine referenceLine = referencePoint.GetContainingLine();
ITextSnapshotLine line = lineSyntax.DelimiterToken.Span.Span.End.GetContainingLine();
SnapshotSpan referenceIndent = new SnapshotSpan(referenceLine.Start, referencePoint);
SnapshotSpan indent = new SnapshotSpan(line.Start, lineSyntax.NameToken.Span.Span.Start);
if (indent.GetText() != referenceIndent.GetText())
{
edit.Replace(indent, referenceIndent.GetText());
}
}
// remove white space before ':'
if (lineSyntax.NameToken.Span.Span.End != lineSyntax.DelimiterToken.Span.Span.Start)
{
edit.Delete(new SnapshotSpan(lineSyntax.NameToken.Span.Span.End, lineSyntax.DelimiterToken.Span.Span.Start));
}
edit.Apply();
}
transaction.Complete();
}
}
}
}
private ITextEdit Fix(RobotsTxtLineSyntax line)
{
ITextBuffer buffer = line.Record.Document.Snapshot.TextBuffer;
string value = line.ValueToken.Value;
// fix
string newValue = value;
// example: * -> /
if (value == "*")
{
newValue = "/";
}
// example: /folder/* -> /folder/
else if (value.EndsWith("/*"))
{
newValue = value.Remove(value.Length - 1);
}
ITextEdit edit = buffer.CreateEdit();
edit.Replace(
line.ValueToken.Span.Span,
newValue
);
return(edit);
}
/// <summary>
/// Normalizes the given buffer to match the given whitespace stype.
/// </summary>
/// <returns>True if the buffer was changed. False otherwise.</returns>
public static bool NormalizeLeadingWhitespace(this ITextBuffer buffer, int tabSize, bool useSpaces)
{
using (var edit = buffer.CreateEdit())
{
var whitespaceCache = new string[100];
foreach (var line in edit.Snapshot.Lines)
{
if (line.Length > 0)
{
AnalyzeWhitespace(line, tabSize, out int whitespaceCharacterLength, out int column);
if (column > 0)
{
var whitespace = GetWhitespace(whitespaceCache, tabSize, useSpaces, column);
if ((whitespace.Length != whitespaceCharacterLength) || !ComparePrefix(line, whitespace))
{
edit.Replace(new Span(line.Start, whitespaceCharacterLength), whitespace);
}
}
}
}
return(edit.Apply() != edit.Snapshot);
}
}
private void FormatSelection(ITextBuffer textBuffer, int insertionIndex, string insertionText)
{
Controller.TextViewData viewData = Controller.TextViewConnectionListener.GetTextViewDataForBuffer(textBuffer);
ITextView textView = viewData.LastActiveView;
using (ITextEdit textEdit = textBuffer.CreateEdit())
{
textEdit.Insert(insertionIndex, insertionText);
textEdit.Apply();
}
IOleCommandTarget commandTarget = Shell.Package.GetGlobalService(typeof(Shell.Interop.SUIHostCommandDispatcher)) as IOleCommandTarget;
SendFocusToEditor(textView);
SnapshotSpan snapshotSpan = new SnapshotSpan(textView.TextSnapshot, insertionIndex, insertionText.Length + 1);
textView.Selection.Select(snapshotSpan, false);
Guid guidVSStd2K = VSConstants.VSStd2K;
commandTarget.Exec(
ref guidVSStd2K,
(uint)VSConstants.VSStd2KCmdID.FORMATSELECTION,
(uint)OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT,
IntPtr.Zero,
IntPtr.Zero);
textView.Selection.Clear();
}
private void StripWhiteSpace(ITextSnapshotLine line)
{
ITextSnapshot snapshot = line.Snapshot;
ITextBuffer textBuffer = snapshot.TextBuffer;
int position = line.Start.Position;
while (position < line.End.Position && IsSpaceCharacter(snapshot[position]))
{
++position;
}
int index = line.End.Position - 1;
while (index > position && IsSpaceCharacter(snapshot[index]))
{
--index;
}
if (index == line.End.Position - 1 && position == line.Start.Position)
{
return;
}
using (ITextEdit edit = textBuffer.CreateEdit())
{
edit.Delete(Span.FromBounds(index + 1, line.End.Position));
edit.Delete(Span.FromBounds(line.Start.Position, position));
edit.Apply();
}
}
/// <summary>
/// Command handler for the history commands.
/// The standard implementation of a console has a history function implemented when
/// the user presses the UP or DOWN key.
/// </summary>
private void OnHistory(object sender, EventArgs e)
{
if (!completionBroker.IsCompletionActive(_textView))
{
// Get the command to figure out from the ID if we have to get the previous or the
// next element in the history.
OleMenuCommand command = sender as OleMenuCommand;
if (null == command ||
command.CommandID.Guid != typeof(Microsoft.VisualStudio.VSConstants.VSStd2KCmdID).GUID)
{
return;
}
string historyEntry = null;
if (command.CommandID.ID == (int)Microsoft.VisualStudio.VSConstants.VSStd2KCmdID.UP)
{
historyEntry = history.PreviousEntry();
}
else if (command.CommandID.ID == (int)Microsoft.VisualStudio.VSConstants.VSStd2KCmdID.DOWN)
{
historyEntry = history.NextEntry();
}
if (string.IsNullOrEmpty(historyEntry))
{
return;
}
int start = GetReadOnlyLength(mefTextBuffer.CurrentSnapshot);
if (!mefTextBuffer.EditInProgress)
{
var edit = mefTextBuffer.CreateEdit();
edit.Replace(new Span(start, mefTextBuffer.CurrentSnapshot.Length - start), historyEntry);
edit.Apply();
}
}
}
private void UpdateVendorValues(ParseItem item)
{
Declaration dec = item.FindType <Declaration>();
if (dec != null && Cache.Contains(dec) && !dec.IsVendorSpecific())
{
// Find all vendor specifics that isn't the standard property.
var matches = Cache.Where(d => d.IsValid && d != dec && d.Parent == dec.Parent && GetStandardName(d) == dec.PropertyName.Text && d.PropertyName.Text != dec.PropertyName.Text);
// Undo sometimes messes with the positions, so we have to make this check before proceeding.
if (!matches.Any() || dec.Text.Length < dec.Colon.AfterEnd - dec.Start || dec.Colon.AfterEnd < dec.Start)
{
return;
}
string text = dec.Text.Substring(dec.Colon.AfterEnd - dec.Start, dec.AfterEnd - dec.Colon.AfterEnd);
using (ITextEdit edit = _buffer.CreateEdit())
{
foreach (Declaration match in matches.Reverse())
{
SnapshotSpan span = new SnapshotSpan(_buffer.CurrentSnapshot, match.Colon.AfterEnd, match.AfterEnd - match.Colon.AfterEnd);
if (span.GetText() != text)
{
edit.Replace(span, text);
}
}
edit.Apply();
}
}
}
public void Edit(Project project)
{
string str = Path.Combine(ProjectExtensions.GetFullPath(project), "web.config");
if (project.DTE.SourceControl.IsItemUnderSCC(str) && !project.DTE.SourceControl.IsItemCheckedOut(str) && !project.DTE.SourceControl.CheckOutItem(str))
{
return;
}
IEditorInterfaces orOpenDocument = this.VisualStudio.Editor.GetOrOpenDocument(str);
Marshal.ThrowExceptionForHR(orOpenDocument.VsTextBuffer.Reload(1));
ITextBuffer textBuffer = orOpenDocument.TextBuffer;
using (ITextEdit textEdit = textBuffer.CreateEdit())
{
string editedText = this.GetEditedText(textEdit.Snapshot.GetText());
if (editedText != null)
{
textEdit.Replace(new Span(0, textBuffer.CurrentSnapshot.Length), editedText);
textEdit.Apply();
this.VisualStudio.Editor.FormatDocument(str);
Document document = project.DTE.Documents.Item(str);
document.Save("");
}
}
}
/// <summary>
/// Removes white space from both ends of a line.
/// </summary>
private void StripWhiteSpace(ITextSnapshotLine line)
{
ITextSnapshot snapshot = line.Snapshot;
ITextBuffer buffer = snapshot.TextBuffer;
int forwardIterator;
int backwardIterator;
// Detect spaces at the beginning
forwardIterator = line.Start.Position;
while (forwardIterator < line.End.Position && IsSpaceCharacter(snapshot[forwardIterator]))
{
++forwardIterator;
}
// Detect spaces at the end
backwardIterator = line.End.Position - 1;
while (backwardIterator > forwardIterator && IsSpaceCharacter(snapshot[backwardIterator]))
{
--backwardIterator;
}
if ((backwardIterator != line.End.Position - 1) || (forwardIterator != line.Start.Position))
{
using (ITextEdit edit = buffer.CreateEdit())
{
edit.Delete(Span.FromBounds(backwardIterator + 1, line.End.Position));
edit.Delete(Span.FromBounds(line.Start.Position, forwardIterator));
edit.Apply();
}
}
}
public sealed override void Apply(IEditorOptions options, ITextBuffer document, CancellationToken cancellationToken, ITextView textView = null)
{
FixNewlines(edits, options, document.CurrentSnapshot);
var selections = textView != null?GetSelectionTrackingSpans(edits, document.CurrentSnapshot) : null;
using var edit = document.CreateEdit();
foreach (var change in edits)
{
switch (change.Kind)
{
case Kind.Insert:
edit.Insert(change.Span.Start, change.Text);
break;
case Kind.Replace:
edit.Replace(change.Span.Start, change.Span.Length, change.Text);
break;
case Kind.Delete:
edit.Delete(change.Span.Start, change.Span.Length);
break;
}
}
edit.Apply();
if (selections != null && selections.Count > 0)
{
ApplySelections(selections, textView);
}
}
/// Takes current text buffer and new text then builds list of changed
/// regions and applies them to the buffer. This way we can avoid
/// destruction of bookmarks and other markers. Complete
/// buffer replacement deletes all markers which causes
/// loss of bookmarks, breakpoints and other similar markers.
public static void ApplyChange(
ITextBuffer textBuffer,
int position,
int length,
string newText,
string transactionName,
ISelectionTracker selectionTracker,
int maxMilliseconds)
{
var snapshot = textBuffer.CurrentSnapshot;
int oldLength = Math.Min(length, snapshot.Length - position);
string oldText = snapshot.GetText(position, oldLength);
var changes = TextChanges.BuildChangeList(oldText, newText, maxMilliseconds);
if (changes != null && changes.Count > 0)
{
using (var selectionUndo = new SelectionUndo(selectionTracker, transactionName, automaticTracking: false)) {
using (ITextEdit edit = textBuffer.CreateEdit()) {
// Replace ranges in reverse so relative positions match
for (int i = changes.Count - 1; i >= 0; i--)
{
TextChange tc = changes[i];
edit.Replace(tc.Position + position, tc.Length, tc.NewText);
}
edit.Apply();
}
}
}
}
private void RemoveTrailingWhitespace(ITextBuffer buffer)
{
bool foundWhitespace = false;
using (ITextEdit edit = buffer.CreateEdit())
{
ITextSnapshot snap = edit.Snapshot;
foreach (ITextSnapshotLine line in snap.Lines)
{
string text = line.GetText();
int length = text.Length;
while (--length >= 0 && Char.IsWhiteSpace(text[length]))
{
;
}
if (length < text.Length - 1)
{
int start = line.Start.Position;
edit.Delete(start + length + 1, text.Length - length - 1);
foundWhitespace = true;
}
}
edit.Apply();
}
if (foundWhitespace)
{
Telemetry.TrackEvent("On save");
}
}
private void DeleteWhiteSpace(ITextBuffer textBuffer)
{
ITextEdit EditBuffer = textBuffer.CreateEdit();
foreach (ITextSnapshotLine Line in EditBuffer.Snapshot.Lines)
{
string sLine = Line.GetText();
int i = Line.Length;
//If this line is empty then move on
if (i == 0)
{
continue;
}
//Start at the end of the line and find the starting index of the whitespace
while (--i >= 0 && Char.IsWhiteSpace(sLine[i]))
{
}
;
++i;
//If we found whitespace then remove it, this if check is unnecessary, but avoids us having to call Delete below unnecessarily
if (i != Line.Length)
{
EditBuffer.Delete(Line.Start.Position + i, Line.Length - i);
}
}
EditBuffer.Apply();
}
private static void UpdateText(ITextBuffer textBuffer, string text)
{
using (var edit = textBuffer.CreateEdit())
{
edit.Replace(0, textBuffer.CurrentSnapshot.Length, text);
edit.Apply();
}
}
private static void UpdateText(ITextBuffer textBuffer, string text)
{
using (var edit = textBuffer.CreateEdit())
{
edit.Replace(0, textBuffer.CurrentSnapshot.Length, text);
edit.Apply();
}
}
public static void SetText(this ITextBuffer buffer, params string[] lines)
{
var text = String.Join(Environment.NewLine, lines);
var edit = buffer.CreateEdit(EditOptions.DefaultMinimalChange, 0, null);
edit.Replace(new Span(0, buffer.CurrentSnapshot.Length), text);
edit.Apply();
}
private static void ApplyEdits(ITextBuffer textBuffer, IList<Edit> edits)
{
using (var vsEdit = textBuffer.CreateEdit())
{
foreach (var edit in edits)
vsEdit.Replace(edit.Start, edit.Length, edit.Text);
vsEdit.Apply();
}
}
static void SetText(ITextBuffer textBuffer, string content)
{
content = content ?? "";
using (var edit = textBuffer.CreateEdit(EditOptions.DefaultMinimalChange, reiteratedVersionNumber: null, editTag: 1)) {
edit.Replace(0, textBuffer.CurrentSnapshot.Length, content);
edit.Apply();
}
}
private static void NotifyBufferVersionUpdated(ITextBuffer textBuffer, long hostDocumentSyncVersion)
{
textBuffer.SetHostDocumentSyncVersion(hostDocumentSyncVersion);
var edit = textBuffer.CreateEdit();
// Content doesn't matter, we're just trying to create an edit that notifies listeners of a changed event.
edit.Insert(0, "Test");
edit.Apply();
}
private static void ApplyChanges(ITextBuffer buffer, IList<TextChange> changes)
{
using (var edit = buffer.CreateEdit())
{
foreach (var change in changes)
{
edit.Replace(change.Span.ToSpan(), change.NewText);
}
edit.Apply();
}
}
/// <summary>
/// Incrementally applies whitespace change to the buffer
/// having old and new tokens produced from the 'before formatting'
/// and 'after formatting' versions of the same text.
/// </summary>
/// <param name="textBuffer">Text buffer to apply changes to</param>
/// <param name="newTextProvider">Text provider of the text fragment before formatting</param>
/// <param name="newTextProvider">Text provider of the formatted text</param>
/// <param name="oldTokens">Tokens from the 'before' text fragment</param>
/// <param name="newTokens">Tokens from the 'after' text fragment</param>
/// <param name="formatRange">Range that is being formatted in the text buffer</param>
/// <param name="transactionName">Name of the undo transaction to open</param>
/// <param name="selectionTracker">Selection tracker object that will save, track
/// <param name="additionalAction">Action to perform after changes are applies by undo unit is not yet closed.</param>
/// and restore selection after changes have been applied.</param>
public static void ApplyChangeByTokens(
ITextBuffer textBuffer,
ITextProvider oldTextProvider,
ITextProvider newTextProvider,
IReadOnlyList<ITextRange> oldTokens,
IReadOnlyList<ITextRange> newTokens,
ITextRange formatRange,
string transactionName,
ISelectionTracker selectionTracker,
IEditorShell editorShell,
Action additionalAction = null) {
Debug.Assert(oldTokens.Count == newTokens.Count);
if (oldTokens.Count == newTokens.Count) {
ITextSnapshot snapshot = textBuffer.CurrentSnapshot;
using (CreateSelectionUndo(selectionTracker, editorShell, transactionName)) {
using (ITextEdit edit = textBuffer.CreateEdit()) {
if (oldTokens.Count > 0) {
// Replace whitespace between tokens in reverse so relative positions match
int oldEnd = oldTextProvider.Length;
int newEnd = newTextProvider.Length;
string oldText, newText;
for (int i = newTokens.Count - 1; i >= 0; i--) {
oldText = oldTextProvider.GetText(TextRange.FromBounds(oldTokens[i].End, oldEnd));
newText = newTextProvider.GetText(TextRange.FromBounds(newTokens[i].End, newEnd));
if (oldText != newText) {
edit.Replace(formatRange.Start + oldTokens[i].End, oldEnd - oldTokens[i].End, newText);
}
oldEnd = oldTokens[i].Start;
newEnd = newTokens[i].Start;
}
newText = newTextProvider.GetText(TextRange.FromBounds(0, newEnd));
edit.Replace(formatRange.Start, oldEnd, newText);
} else {
string newText = newTextProvider.GetText(TextRange.FromBounds(0, newTextProvider.Length));
edit.Replace(formatRange.Start, formatRange.Length, newText);
}
edit.Apply();
additionalAction?.Invoke();
}
}
}
}
private void RemoveTrailingWhitespace(ITextBuffer buffer)
{
using (ITextEdit edit = buffer.CreateEdit())
{
ITextSnapshot snap = edit.Snapshot;
foreach (ITextSnapshotLine line in snap.Lines)
{
string text = line.GetText();
int length = text.Length;
while (--length >= 0 && Char.IsWhiteSpace(text[length])) ;
if (length < text.Length - 1)
{
int start = line.Start.Position;
edit.Delete(start + length + 1, text.Length - length - 1);
}
}
edit.Apply();
}
}
private static void ReplaceContentsInsideTextBuffer(ITextBuffer textBuffer, string oldText, string newText)
{
ITextEdit edit = textBuffer.CreateEdit();
edit.Replace(0, oldText.Length, newText);
edit.Apply();
}
/// <summary>
/// Attempts to run code cleanup on the specified generic document.
/// </summary>
/// <param name="document">The document for cleanup.</param>
/// <param name="textBuffer">The text buffer for the document.</param>
private void RunCodeCleanupGeneric(Document document, ITextBuffer textBuffer)
{
ITextDocument textDocument;
var doc = (TextDocument)document.Object("TextDocument");
textBuffer.Properties.TryGetProperty(typeof(ITextDocument), out textDocument);
var path = doc.Parent.FullName;
FileConfiguration settings;
if (!ConfigLoader.TryLoad(path, out settings))
return;
using (ITextEdit edit = textBuffer.CreateEdit())
{
ITextSnapshot snapshot = edit.Snapshot;
if (settings.Charset != null && textDocument != null)
FixDocumentCharset(textDocument, settings.Charset.Value);
if (settings.TryKeyAsBool("trim_trailing_whitespace"))
TrimTrailingWhitespace(snapshot, edit);
if (settings.TryKeyAsBool("insert_final_newline"))
InsertFinalNewline(snapshot, edit, settings.EndOfLine());
var eol = settings.EndOfLine();
FixLineEndings(snapshot, edit, eol);
edit.Apply();
}
}
// Stolen from Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem.DocumentProvider.StandardTextDocument
private static void UpdateText(SourceText newText, ITextBuffer buffer, EditOptions options)
{
using (ITextEdit textEdit = buffer.CreateEdit(options, null, null))
{
SourceText oldText = buffer.CurrentSnapshot.AsText();
foreach (var current in newText.GetTextChanges(oldText))
{
textEdit.Replace(current.Span.Start, current.Span.Length, current.NewText);
}
textEdit.Apply();
}
}
private static void UpdateText(SourceText newText, ITextBuffer buffer, EditOptions options)
{
using (var edit = buffer.CreateEdit(options, reiteratedVersionNumber: null, editTag: null))
{
var oldSnapshot = buffer.CurrentSnapshot;
var oldText = oldSnapshot.AsText();
var changes = newText.GetTextChanges(oldText);
Workspace workspace = null;
if (Workspace.TryGetWorkspace(oldText.Container, out workspace))
{
var undoService = workspace.Services.GetService<ISourceTextUndoService>();
undoService.BeginUndoTransaction(oldSnapshot);
}
foreach (var change in changes)
{
edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
}
edit.Apply();
}
}
private static string GetFormattedText(ITextBuffer buffer, IList<TextChange> changes)
{
using (var edit = buffer.CreateEdit())
{
foreach (var change in changes)
{
edit.Replace(change.Span.ToSpan(), change.NewText);
}
edit.Apply();
}
return buffer.CurrentSnapshot.GetText();
}
public bool ReplaceAll(ITextBuffer tb) {
Contract.Assume(tb != null);
var tra = new TacticReplacerActor(tb);
var isMoreMembers = tra.NextMemberInTld();
var replaceStatus = TacticReplaceStatus.Success;
var tedit = tb.CreateEdit();
try
{
while (isMoreMembers && (replaceStatus == TacticReplaceStatus.Success || replaceStatus == TacticReplaceStatus.NoTactic))
{
var isMoreTactics = tra.NextTacticCallInMember();
while (isMoreTactics && (replaceStatus == TacticReplaceStatus.Success || replaceStatus == TacticReplaceStatus.NoTactic))
{
replaceStatus = tra.ReplaceSingleTacticCall(tedit);
isMoreTactics = tra.NextTacticCallInMember();
}
isMoreMembers = tra.NextMemberInTld();
}
if(replaceStatus==TacticReplaceStatus.Success || replaceStatus == TacticReplaceStatus.NoTactic)
{ tedit.Apply();} else { tedit.Dispose();}
} catch { tedit.Dispose(); }
return NotifyOfReplacement(replaceStatus);
}
private void AppendLineNoPromptInjection(ITextBuffer buffer)
{
using (var edit = buffer.CreateEdit(EditOptions.None, null, SuppressPromptInjectionTag))
{
edit.Insert(buffer.CurrentSnapshot.Length, _lineBreakString);
edit.Apply();
}
}
private static void UpdateText(SourceText newText, ITextBuffer buffer, EditOptions options)
{
using (var edit = buffer.CreateEdit(options, reiteratedVersionNumber: null, editTag: null))
{
var oldText = buffer.CurrentSnapshot.AsText();
var changes = newText.GetTextChanges(oldText);
foreach (var change in changes)
{
edit.Replace(change.Span.Start, change.Span.Length, change.NewText);
}
edit.Apply();
}
}
private static ITextSnapshot ApplyChanges(ITextBuffer buffer, params TextChange[] changes)
{
using (var edit = buffer.CreateEdit())
{
foreach (var change in changes)
{
edit.Replace(change.Start, change.Length, change.Text);
}
return edit.Apply();
}
}
private static void UpdateFromImport(
PythonAst curAst,
ITextBuffer buffer,
FromImportStatement fromImport,
string name
) {
NameExpression[] names = new NameExpression[fromImport.Names.Count + 1];
NameExpression[] asNames = fromImport.AsNames == null ? null : new NameExpression[fromImport.AsNames.Count + 1];
NameExpression newName = new NameExpression(name);
for (int i = 0; i < fromImport.Names.Count; i++) {
names[i] = fromImport.Names[i];
}
names[fromImport.Names.Count] = newName;
if (asNames != null) {
for (int i = 0; i < fromImport.AsNames.Count; i++) {
asNames[i] = fromImport.AsNames[i];
}
}
var newImport = new FromImportStatement((ModuleName)fromImport.Root, names, asNames, fromImport.IsFromFuture, fromImport.ForceAbsolute);
curAst.CopyAttributes(fromImport, newImport);
var newCode = newImport.ToCodeString(curAst);
var span = fromImport.GetSpan(curAst);
int leadingWhiteSpaceLength = (fromImport.GetLeadingWhiteSpace(curAst) ?? "").Length;
using (var edit = buffer.CreateEdit()) {
edit.Delete(span.Start.Index - leadingWhiteSpaceLength, span.Length + leadingWhiteSpaceLength);
edit.Insert(span.Start.Index, newCode);
edit.Apply();
}
}