public static IDocumentIndentEngine CreateEngine(string text)
{
var sb = new StringBuilder();
int offset = 0;
for (int i = 0; i < text.Length; i++)
{
var ch = text [i];
if (ch == '$')
{
offset = i;
continue;
}
sb.Append(ch);
}
var data = new TextEditorData();
data.Text = sb.ToString();
var csi = new JSonIndentEngine(data);
var result = new CacheIndentEngine(csi);
result.Update(offset);
return(result);
}
public static void RandomTests(string filePath, int count, CSharpFormattingOptions policy = null, TextEditorOptions options = null)
{
if (File.Exists(filePath))
{
var code = File.ReadAllText(filePath);
var document = new ReadOnlyDocument(code);
policy = policy ?? FormattingOptionsFactory.CreateMono();
options = options ?? new TextEditorOptions {
IndentBlankLines = false
};
var engine = new CacheIndentEngine(new CSharpIndentEngine(document, options, policy)
{
EnableCustomIndentLevels = true
});
Random rnd = new Random();
for (int i = 0; i < count; i++)
{
int offset = rnd.Next(document.TextLength);
engine.Update(offset);
if (engine.CurrentIndent.Length == 0)
{
continue;
}
}
}
else
{
Assert.Fail("File " + filePath + " doesn't exist.");
}
}
internal static CacheIndentEngine CreateEngine(string text, out SourceText sourceText, OptionSet options = null)
{
if (options == null)
{
options = FormattingOptionsFactory.CreateMono();
// options.AlignToFirstIndexerArgument = formatOptions.AlignToFirstMethodCallArgument = true;
}
var sb = new StringBuilder();
int offset = 0;
for (int i = 0; i < text.Length; i++)
{
var ch = text [i];
if (ch == '$')
{
offset = i;
continue;
}
sb.Append(ch);
}
sourceText = SourceText.From(sb.ToString());
var result = new CacheIndentEngine(new CSharpIndentEngine(options));
result.Update(sourceText, offset);
return(result);
}
ITextPasteHandler CreateTextPasteIndentEngine(CacheIndentEngine indent, OptionSet optionSet)
{
return(new TextPasteIndentEngine(indent, optionSet)
{
InUnitTestMode = true
});
}
public static void RandomTests(string filePath, int count, OptionSet options = null)
{
if (File.Exists(filePath))
{
var code = File.ReadAllText(filePath);
var document = SourceText.From(code);
options = options ?? FormattingOptionsFactory.CreateMono();
var engine = new CacheIndentEngine(new CSharpIndentEngine(options)
{
EnableCustomIndentLevels = true
});
Random rnd = new Random();
for (int i = 0; i < count; i++)
{
int offset = rnd.Next(document.Length);
engine.Update(document, offset);
if (engine.CurrentIndent.Length == 0)
{
continue;
}
}
}
else
{
Assert.Fail("File " + filePath + " doesn't exist.");
}
}
public static IDocumentIndentEngine CreateEngine(string text)
{
var sb = new StringBuilder();
int offset = 0;
for (int i = 0; i < text.Length; i++)
{
var ch = text [i];
if (ch == '$')
{
offset = i;
continue;
}
sb.Append(ch);
}
var tww = new TestWorkbenchWindow();
var content = new TestViewContent();
tww.ViewContent = content;
content.ContentName = "/a.json";
content.Data.MimeType = "application/json";
content.Data.Text = sb.ToString();
var doc = new MonoDevelop.Ide.Gui.Document(tww);
var csi = new JSonIndentEngine(content.Data, doc);
var result = new CacheIndentEngine(csi);
result.Update(content.Data, offset);
return(result);
}
public static CacheIndentEngine CreateEngine(string text, CSharpFormattingOptions formatOptions = null, TextEditorOptions options = null)
{
if (formatOptions == null)
{
formatOptions = FormattingOptionsFactory.CreateMono();
formatOptions.AlignToFirstIndexerArgument = formatOptions.AlignToFirstMethodCallArgument = true;
}
var sb = new StringBuilder();
int offset = 0;
for (int i = 0; i < text.Length; i++)
{
var ch = text [i];
if (ch == '$')
{
offset = i;
continue;
}
sb.Append(ch);
}
var document = new ReadOnlyDocument(sb.ToString());
options = options ?? new TextEditorOptions {
EolMarker = "\n"
};
var result = new CacheIndentEngine(new CSharpIndentEngine(document, options, formatOptions));
result.Update(offset);
return(result);
}
void HandleTextOptionsChanged (object sender, EventArgs e)
{
var policy = Policy.CreateOptions ();
var options = Editor.CreateNRefactoryTextEditorOptions ();
options.IndentBlankLines = true;
IStateMachineIndentEngine indentEngine;
try {
var csharpIndentEngine = new CSharpIndentEngine (textEditorData.Document, options, policy);
//csharpIndentEngine.EnableCustomIndentLevels = true;
foreach (var symbol in MonoDevelop.CSharp.Highlighting.CSharpSyntaxMode.GetDefinedSymbols (document.Project)) {
csharpIndentEngine.DefineSymbol (symbol);
}
indentEngine = csharpIndentEngine;
} catch (Exception ex) {
LoggingService.LogError ("Error while creating the c# indentation engine", ex);
indentEngine = new NullIStateMachineIndentEngine (textEditorData.Document);
}
stateTracker = new CacheIndentEngine (indentEngine);
textEditorData.IndentationTracker = new IndentVirtualSpaceManager (textEditorData, stateTracker);
if (textEditorData.Options.IndentStyle == IndentStyle.Auto || textEditorData.Options.IndentStyle == IndentStyle.None) {
textEditorData.TextPasteHandler = null;
} else {
textEditorData.TextPasteHandler = new TextPasteIndentEngine (stateTracker, options, policy);
}
}
public override void Initialize()
{
base.Initialize();
if (textEditorData != null)
{
textEditorData.Options.Changed += HandleTextOptionsChanged;
var policy = Policy.CreateOptions();
var options = Editor.CreateNRefactoryTextEditorOptions();
options.IndentBlankLines = true;
var engine = new CacheIndentEngine(new ICSharpCode.NRefactory.CSharp.CSharpIndentEngine(textEditorData.Document, options, policy));
textEditorData.IndentationTracker = new IndentVirtualSpaceManager(
textEditorData,
engine
);
textEditorData.Document.TextReplacing += HandleTextReplacing;
textEditorData.Document.TextReplaced += HandleTextReplaced;
textEditorData.TextPasteHandler = new TextPasteIndentEngine(engine.Clone(), options);
textEditorData.Paste += HandleTextPaste;
}
InitTracker();
}
public override void Initialize()
{
base.Initialize();
IStateMachineIndentEngine indentEngine;
indentEngine = new JSonIndentEngine(document.Editor);
stateTracker = new CacheIndentEngine(indentEngine);
document.Editor.IndentationTracker = new JSonIndentationTracker(document.Editor, stateTracker);
}
protected override void Initialize()
{
base.Initialize();
IStateMachineIndentEngine indentEngine;
indentEngine = new JSonIndentEngine(Editor, DocumentContext);
stateTracker = new CacheIndentEngine(indentEngine);
Editor.SetIndentationTracker(new JSonIndentationTracker(Editor, stateTracker));
}
IStateMachineIndentEngine CreateTracker(TextEditorData data)
{
var policy = PolicyService.InvariantPolicies.Get <CSharpFormattingPolicy> ("text/x-csharp").CreateOptions();
var textStylePolicy = data.CreateNRefactoryTextEditorOptions();
textStylePolicy.IndentBlankLines = true;
var result = new CacheIndentEngine(new ICSharpCode.NRefactory.CSharp.CSharpIndentEngine(data.Document, textStylePolicy, policy));
result.Update(data.Caret.Offset);
return(result);
}
static void IndentSingleLine(CacheIndentEngine engine, IDocument document, IDocumentLine line)
{
engine.Update(line.EndOffset);
if (engine.NeedsReindent)
{
var indentation = TextUtilities.GetWhitespaceAfter(document, line.Offset);
// replacing the indentation in two steps is necessary to make the caret move accordingly.
document.Replace(indentation.Offset, indentation.Length, "");
document.Replace(indentation.Offset, 0, engine.ThisLineIndent);
engine.ResetEngineToPosition(line.Offset);
}
}
public override void Dispose ()
{
if (textEditorData != null) {
textEditorData.TextPasteHandler = null;
textEditorData.Paste -= HandleTextPaste;
textEditorData.Options.Changed -= HandleTextOptionsChanged;
textEditorData.IndentationTracker = null;
textEditorData.Document.TextReplacing -= HandleTextReplacing;
textEditorData.Document.TextReplaced -= HandleTextReplaced;
}
IdeApp.Workspace.ActiveConfigurationChanged -= HandleTextOptionsChanged;
stateTracker = null;
base.Dispose ();
}
public static void ReadAndTest(string filePath, CSharpFormattingOptions policy = null, TextEditorOptions options = null)
{
if (File.Exists(filePath))
{
filePath = Path.GetFullPath(filePath);
var code = File.ReadAllText(filePath);
var document = new ReadOnlyDocument(code);
if (policy == null)
{
policy = FormattingOptionsFactory.CreateMono();
policy.AlignToFirstIndexerArgument = policy.AlignToFirstMethodCallArgument = true;
}
options = options ?? new TextEditorOptions {
IndentBlankLines = false, EolMarker = "\n"
};
var engine = new CacheIndentEngine(new CSharpIndentEngine(document, options, policy)
{
EnableCustomIndentLevels = true
});
int errors = 0;
foreach (var ch in code)
{
if (options.EolMarker[0] == ch)
{
if (!(engine.LineBeganInsideMultiLineComment || engine.LineBeganInsideVerbatimString))
{
if (engine.CurrentIndent.Length > 0)
{
if (engine.NeedsReindent)
{
errors++;
Console.WriteLine(string.Format("Indent: {2}, Current indent: {3} in {0}:{1}", filePath, engine.Location.Line, engine.ThisLineIndent.Length, engine.CurrentIndent.Length));
}
}
}
}
engine.Push(ch);
}
Assert.AreEqual(0, errors);
}
else
{
Assert.Fail("File " + filePath + " doesn't exist.");
}
}
public static void ReadAndTest(string filePath, OptionSet options = null)
{
if (File.Exists(filePath))
{
filePath = Path.GetFullPath(filePath);
var code = File.ReadAllText(filePath);
var document = SourceText.From(code);
if (options == null)
{
options = FormattingOptionsFactory.CreateMono();
//policy.AlignToFirstIndexerArgument = policy.AlignToFirstMethodCallArgument = true;
}
var engine = new CacheIndentEngine(new CSharpIndentEngine(options)
{
EnableCustomIndentLevels = true
});
int errors = 0;
var newLine = options.GetOption(FormattingOptions.NewLine, LanguageNames.CSharp);
foreach (var ch in code)
{
if (newLine [0] == ch)
{
if (!(engine.LineBeganInsideMultiLineComment || engine.LineBeganInsideVerbatimString))
{
if (engine.CurrentIndent.Length > 0)
{
if (engine.NeedsReindent)
{
errors++;
var line = document.Lines.GetLineFromPosition(engine.Offset);
Console.WriteLine(string.Format("Indent: {2}, Current indent: {3} in {0}:{1}", filePath, line.LineNumber, GetIndentString(engine.ThisLineIndent), GetIndentString(engine.CurrentIndent)));
}
}
}
}
engine.Push(ch);
}
Assert.AreEqual(0, errors, "file has errors");
}
else
{
Assert.Fail("File " + filePath + " doesn't exist.");
}
}
public static IDocumentIndentEngine CreateEngine(string text, OptionSet formatOptions = null, IEnumerable <string> symbols = null)
{
var policy = formatOptions;
if (policy == null)
{
policy = FormattingOptionsFactory.CreateMono();
// policy.IndentPreprocessorDirectives = false;
// policy.AlignToFirstMethodCallArgument = policy.AlignToFirstIndexerArgument = true;
}
var sb = new StringBuilder();
int offset = 0;
for (int i = 0; i < text.Length; i++)
{
var ch = text[i];
if (ch == '$')
{
offset = i;
continue;
}
sb.Append(ch);
}
var document = SourceText.From(sb.ToString());
var csi = new CSharpIndentEngine(policy)
{
EnableCustomIndentLevels = true
};
if (symbols != null)
{
foreach (var sym in symbols)
{
csi.DefineSymbol(sym);
}
}
var result = new CacheIndentEngine(csi);
result.Update(document, offset);
return(result);
}
protected override void Initialize()
{
base.Initialize();
// This extension needs to be turned off if the webtooling addin json extension is present.
// That addin defines a "text/x-json" mimeType that has multiple levels of inheritance.
var mimeChain = IdeServices.DesktopService.GetMimeTypeInheritanceChain("text/x-json").ToList();
jsonExtensionInstalled = (mimeChain.Count > 2);
if (!jsonExtensionInstalled)
{
IStateMachineIndentEngine indentEngine;
indentEngine = new JSonIndentEngine(Editor);
stateTracker = new CacheIndentEngine(indentEngine);
Editor.IndentationTracker = new JSonIndentationTracker(Editor, stateTracker);
}
}
public override void Dispose()
{
if (textEditorData != null)
{
textEditorData.TextPasteHandler = null;
textEditorData.Paste -= HandleTextPaste;
textEditorData.Options.Changed -= HandleTextOptionsChanged;
textEditorData.IndentationTracker = null;
textEditorData.Document.TextReplacing -= HandleTextReplacing;
textEditorData.Document.TextReplaced -= HandleTextReplaced;
}
if (stateTracker != null)
{
stateTracker.Dispose();
stateTracker = null;
}
base.Dispose();
}
public void TestIncreaseIndent()
{
var editor = TextEditorFactory.CreateNewEditor();
editor.Text = @"do
";
var engine = new CacheIndentEngine(new TextMateDocumentIndentEngine(
editor,
new Regex("^\\s*do\\s*$"),
null,
null,
null
));
engine.Update(editor, 2);
Assert.AreEqual("", engine.CurrentIndent);
Assert.AreEqual("\t", engine.ThisLineIndent);
Assert.AreEqual("\t", engine.NextLineIndent);
}
void HandleTextOptionsChanged(object sender, EventArgs e)
{
var policy = Policy.CreateOptions();
var options = Editor.CreateNRefactoryTextEditorOptions();
options.IndentBlankLines = true;
IStateMachineIndentEngine indentEngine;
try {
indentEngine = new CSharpIndentEngine(textEditorData.Document, options, policy);
} catch (Exception ex) {
LoggingService.LogError("Error while creating the c# indentation engine", ex);
indentEngine = new NullIStateMachineIndentEngine(textEditorData.Document);
}
if (stateTracker != null)
{
stateTracker.Dispose();
}
stateTracker = new CacheIndentEngine(indentEngine);
textEditorData.IndentationTracker = new IndentVirtualSpaceManager(textEditorData, stateTracker);
textEditorData.TextPasteHandler = new TextPasteIndentEngine(stateTracker, options, policy);
}
public static async Task <TestCase> Create(string text, bool tabsToSpaces = false)
{
var test = new TestCase();
var sb = new StringBuilder();
int offset = 0;
for (int i = 0; i < text.Length; i++)
{
var ch = text [i];
if (ch == '$')
{
offset = i;
continue;
}
sb.Append(ch);
}
var content = new TestViewContent();
await content.Initialize(new FileDescriptor ("/a.json", null, null));
content.Editor.MimeType = "application/json";
content.Editor.Text = sb.ToString();
test.testCase = await TextEditorExtensionTestCase.Create(content, null, false);
test.testCase.Document.Editor.Options = new CustomEditorOptions {
TabsToSpaces = tabsToSpaces,
TabSize = 4
};
var csi = new JSonIndentEngine(content.Editor);
var result = new CacheIndentEngine(csi);
result.Update(content.Editor, offset);
test.Engine = result;
return(test);
}
public JSonIndentationTracker(TextEditorData data, CacheIndentEngine stateTracker)
{
this.data = data;
this.stateTracker = stateTracker;
}
public IndentVirtualSpaceManager(TextEditorData data, CacheIndentEngine stateTracker)
{
this.data = data;
this.stateTracker = stateTracker;
}
