private void T(string xml, int windowStart, int windowLength, params XmlClassificationTypes[] expectedClassifications)
{
var root = Parser.ParseText(xml);
var actualClassifications = new List <XmlClassificationTypes>();
int start = windowStart;
int length = 0;
ClassifierVisitor.Visit(
root,
windowStart,
windowLength,
(spanStart, spanLength, spanNode, spanClassification) =>
{
Assert.True(spanStart >= start, $"Classified span start ({spanStart}) is less than expected {start}");
start = spanStart + spanLength;
length += spanLength;
actualClassifications.Add(spanClassification);
});
//Assert.Equal (windowLength, length);
if (expectedClassifications != null && expectedClassifications.Length > 0)
{
var equal = Enumerable.SequenceEqual(expectedClassifications, actualClassifications);
var prefix = new string(' ', 16) + "XmlClassificationTypes.";
var actualText = string.Join(",\r\n", actualClassifications
.Select(s => prefix + s)) + ");";
var differsAt = !equal?Enumerable.Range(0, System.Math.Min(expectedClassifications.Length, actualClassifications.Count)).First(i => actualClassifications[i] != expectedClassifications[i]) : 0;
// Clipboard.SetText(actualText);
Assert.True(equal, "classifications differ at index " + differsAt + " i.e. " + expectedClassifications[differsAt] + " vs " + actualClassifications[differsAt] + ". Actual:\r\n" + actualText);
}
}
public void Classify(RichTextBox richTextBox, string text)
{
var document = richTextBox.Document;
Paragraph paragraph = new Paragraph();
document.Blocks.Add(paragraph);
if (!Utilities.LooksLikeXml(text))
{
paragraph.Inlines.Add(text);
return;
}
var contentStart = document.ContentStart;
var sw = Stopwatch.StartNew();
var root = Parser.ParseText(text);
var elapsed = sw.Elapsed;
sw = Stopwatch.StartNew();
ClassifierVisitor.Visit(root, 0, text.Length, (start, length, node, classification) =>
{
var brush = brushes[(int)classification];
var inline = new Run(text.Substring(start, length));
if (brush != null)
{
inline.Foreground = brush;
}
paragraph.Inlines.Add(inline);
});
elapsed = sw.Elapsed;
}
public void T(string xml, int windowStart, int windowLength, params XmlClassificationTypes[] expectedClassifications)
{
var root = Parser.ParseText(xml);
var actualClassifications = new List <XmlClassificationTypes>();
int start = windowStart;
int length = 0;
ClassifierVisitor.Visit(
root,
windowStart,
windowLength,
(spanStart, spanLength, spanNode, spanClassification) =>
{
Assert.IsTrue(spanStart >= start, $"Classified span start ({spanStart}) is less than expected {start}");
start = spanStart + spanLength;
length += spanLength;
actualClassifications.Add(spanClassification);
});
Assert.AreEqual(windowLength, length);
if (expectedClassifications != null && expectedClassifications.Length > 0)
{
var equal = Enumerable.SequenceEqual(expectedClassifications, actualClassifications);
var prefix = new string(' ', 16) + "XmlClassificationTypes.";
var actualText = string.Join(",\r\n", actualClassifications
.Select(s => prefix + s)) + ");";
Clipboard.SetText(actualText);
Assert.IsTrue(equal, "classifications differ. Actual:\r\n" + actualText);
}
}
public void T(string xml, params XmlClassificationTypes[] expectedClassifications)
{
var root = Parser.ParseText(xml);
var actualClassifications = new List <XmlClassificationTypes>();
ClassifierVisitor.Visit(root, 0, xml.Length, (s, e, n, c) => actualClassifications.Add(c));
var equal = Enumerable.SequenceEqual(expectedClassifications, actualClassifications);
Assert.IsTrue(equal, "classifications differ. Actual: " + string.Join(",\r\n", actualClassifications));
}
private static void Classify(BoundSourceFileBuilder binder, XmlDocumentSyntax parsedXml)
{
ClassifierVisitor.Visit(parsedXml, 0, parsedXml.FullWidth, (start, length, node, classification) =>
{
var leadingTriviaWidth = node.GetLeadingTriviaWidth();
var trailingTriviaWidth = node.GetTrailingTriviaWidth();
start += leadingTriviaWidth;
length -= (leadingTriviaWidth + trailingTriviaWidth);
binder.AnnotateClassification(start, length, ClassificationTypeNamesLookup[(int)classification]);
});
}
public IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
// don't classify documents larger than 5 MB, arbitrary large number
if (span.Snapshot.Length > 5000000)
{
return(emptySpanList);
}
var task = parserService.GetSyntaxTree(span.Snapshot);
// wait for 100 milliseconds to see if we're lucky and it finishes before that
// this helps significantly reduce flicker since we're not going to clear and re-add all tags on every keystroke
task.Wait(100);
if (task.Status == TaskStatus.RanToCompletion)
{
var root = task.Result;
var spans = new List <ClassificationSpan>();
ClassifierVisitor.Visit(
root,
span.Start,
span.Length,
(start, length, node, xmlClassification) => spans.Add(
new ClassificationSpan(
new SnapshotSpan(
span.Snapshot,
start,
length),
types[(int)xmlClassification])));
return(spans);
}
task.ContinueWith(t =>
{
RaiseClassificationChanged(span.Snapshot);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
return(emptySpanList);
}
public void Generate(string sourceXmlFilePath, string destinationHtmlFilePath, string solutionDestinationFolder)
{
Log.Write(destinationHtmlFilePath);
this.sourceXmlFilePath = Path.GetFullPath(sourceXmlFilePath);
this.destinationHtmlFilePath = destinationHtmlFilePath;
sourceText = File.ReadAllText(sourceXmlFilePath);
var lines = File.ReadAllLines(sourceXmlFilePath);
lineLengths = TextUtilities.GetLineLengths(sourceText);
var lineCount = lines.Length;
var root = Parser.ParseText(sourceText);
var sb = new StringBuilder();
var relativePathToRoot = Paths.CalculateRelativePathToRoot(destinationHtmlFilePath, solutionDestinationFolder);
var prefix = Markup.GetDocumentPrefix(Path.GetFileName(sourceXmlFilePath), relativePathToRoot, lineCount, "ix");
sb.Append(prefix);
var displayName = GetDisplayName();
var assemblyName = GetAssemblyName();
var url = "/#" + assemblyName + "/" + displayName.Replace('\\', '/');
var file = string.Format("File: <a id=\"filePath\" class=\"blueLink\" href=\"{0}\" target=\"_top\">{1}</a><br/>", url, displayName);
var row = string.Format("<tr><td>{0}</td></tr>", file);
Markup.WriteLinkPanel(s => sb.AppendLine(s), row);
// pass a value larger than 0 to generate line numbers statically at HTML generation time
var table = Markup.GetTablePrefix();
sb.AppendLine(table);
var ranges = new List <ClassifiedRange>();
ClassifierVisitor.Visit(
root,
0,
sourceText.Length,
(start, length, node, classification) =>
{
var line = TextUtilities.GetLineFromPosition(start, sourceText);
var lineText = sourceText.Substring(line.Item1, line.Item2);
ranges.Add(
new ClassifiedRange
{
Classification = classification,
Node = node,
Text = sourceText.Substring(start, length),
LineText = lineText,
LineStart = line.Item1,
LineNumber = TextUtilities.GetLineNumber(start, lineLengths),
Start = start,
Length = length
});
});
ranges = RangeUtilities.FillGaps(
sourceText,
ranges,
r => r.Start,
r => r.Length,
(s, l, t) => new ClassifiedRange
{
Start = s,
Length = l,
Text = t.Substring(s, l)
}).ToList();
foreach (var range in ranges)
{
GenerateRange(range, sb);
}
var suffix = Markup.GetDocumentSuffix();
sb.AppendLine(suffix);
var folder = Path.GetDirectoryName(destinationHtmlFilePath);
Directory.CreateDirectory(folder);
File.WriteAllText(destinationHtmlFilePath, sb.ToString());
}
private string GetHtml(string sourceXmlFilePath, string destinationHtmlFilePath, string displayName)
{
var lines = File.ReadAllLines(sourceXmlFilePath);
lineLengths = sourceText.GetLineLengths();
var lineCount = lines.Length;
var sb = new StringBuilder();
var relativePathToRoot = Paths.CalculateRelativePathToRoot(destinationHtmlFilePath, ProjectGenerator.SolutionGenerator.SolutionDestinationFolder);
var prefix = Markup.GetDocumentPrefix(Path.GetFileName(sourceXmlFilePath), relativePathToRoot, lineCount, "ix");
sb.Append(prefix);
var assemblyName = GetAssemblyName();
var url = "/#" + assemblyName + "/" + displayName.Replace('\\', '/');
Markup.WriteLinkPanel(
s => sb.AppendLine(s),
fileLink: (displayName, url),
webAccessUrl: ProjectGenerator.GetWebAccessUrl(sourceXmlFilePath),
projectLink: (ProjectGenerator.ProjectSourcePath, Url: "/#" + assemblyName, assemblyName));
// pass a value larger than 0 to generate line numbers statically at HTML generation time
var table = Markup.GetTablePrefix();
sb.AppendLine(table);
if (sourceText.Length > 1000000)
{
sb.AppendLine(Markup.HtmlEscape(sourceText));
}
else
{
var ranges = new List <ClassifiedRange>();
var root = Parser.ParseText(sourceText);
ClassifierVisitor.Visit(
root,
0,
sourceText.Length,
(start, length, node, classification) =>
{
var line = TextUtilities.GetLineFromPosition(start, sourceText);
var lineText = sourceText.Substring(line.Item1, line.Item2);
ranges.Add(
new ClassifiedRange
{
Classification = classification,
Node = node,
Text = sourceText.Substring(start, length),
LineText = lineText,
LineStart = line.Item1,
LineNumber = TextUtilities.GetLineNumber(start, lineLengths),
Start = start,
Length = length
});
});
ranges = RangeUtilities.FillGaps(
sourceText,
ranges,
r => r.Start,
r => r.Length,
(s, l, t) => new ClassifiedRange
{
Start = s,
Length = l,
Text = t.Substring(s, l)
}).ToList();
foreach (var range in ranges)
{
GenerateRange(range, sb);
}
}
var suffix = Markup.GetDocumentSuffix();
sb.AppendLine(suffix);
return(sb.ToString());
}
