protected void ClassifyTemplateBody(ITextSnapshot snapshot, List <ClassificationSpan> spans, TemplateRegion region, int prefixLength, int suffixLength)
{
switch (region.Kind)
{
case TemplateTokenKind.Comment:
spans.Add(
new ClassificationSpan(
new SnapshotSpan(
snapshot,
new Span(region.Start + prefixLength, region.Text.Length - (prefixLength + suffixLength))
),
_classifierProvider._commentClassType
)
);
break;
case TemplateTokenKind.Variable:
var filterInfo = DjangoVariable.Parse(region.Text);
if (filterInfo != null)
{
foreach (var curSpan in filterInfo.GetSpans())
{
spans.Add(ToClassificationSpan(curSpan, snapshot, region.Start));
}
}
break;
case TemplateTokenKind.Block:
var blockInfo = region.Block ?? DjangoBlock.Parse(region.Text);
if (blockInfo != null)
{
foreach (var curSpan in blockInfo.GetSpans())
{
spans.Add(ToClassificationSpan(curSpan, snapshot, region.Start));
}
}
else if (region.Text.Length > (prefixLength + suffixLength)) // unterminated block at end of file
{
spans.Add(
new ClassificationSpan(
new SnapshotSpan(
snapshot,
new Span(region.Start + prefixLength, region.Text.Length - (prefixLength + suffixLength))
),
_classifierProvider._classType
)
);
}
break;
}
}
private static void ValidateArgumentless(DjangoBlock expected, DjangoBlock got) {
var aeExpected = (DjangoArgumentlessBlock)expected;
var aeGot = (DjangoArgumentlessBlock)got;
Assert.AreEqual(aeExpected.ParseInfo.Start, aeGot.ParseInfo.Start);
Assert.AreEqual(aeExpected.ParseInfo.Command, aeGot.ParseInfo.Command);
Assert.AreEqual(aeExpected.ParseInfo.Args, aeGot.ParseInfo.Args);
}
private void ValidateBlock(DjangoBlock expected, DjangoBlock got) {
Assert.AreEqual(expected.GetType(), got.GetType());
_blockValidators[expected.GetType()](expected, got);
}
private static void ValidateFilter(DjangoBlock expected, DjangoBlock got) {
var filterExpected = (DjangoFilterBlock)expected;
var filterGot = (DjangoFilterBlock)got;
Assert.AreEqual(filterExpected.ParseInfo.Start, filterGot.ParseInfo.Start);
Assert.AreEqual(filterExpected.ParseInfo.Command, filterGot.ParseInfo.Command);
Assert.AreEqual(filterExpected.ParseInfo.Args, filterGot.ParseInfo.Args);
}
private static void ValidateForBlock(DjangoBlock expected, DjangoBlock got) {
var forExpected = (DjangoForBlock)expected;
var forGot = (DjangoForBlock)got;
Assert.AreEqual(forExpected.ParseInfo.Start, forGot.ParseInfo.Start);
Assert.AreEqual(forExpected.InStart, forGot.InStart);
}
public void DiskBufferChanged(object sender, TextContentChangedEventArgs e)
{
foreach (var change in e.Changes)
{
int closest;
if (TryGetSingleStartSpan(e, change, out closest))
{
var closestSpan = _spans[closest];
int recalcPosition = -1;
bool recalc = false;
if (closestSpan.Kind == TemplateTokenKind.Text)
{
// we're in a section of HTML or whatever language the actual template is being applied to.
// First, check and see if the user has just pasted some code which includes a template,
// in which case we'll recalculate everything.
if (!(recalc = ContainsTemplateMarkup(change)))
{
// Then see if they inserted/deleted text creates a template tag by being merged
// with the text around us.
if (change.NewSpan.Start != 0 && change.NewSpan.End < e.After.Length)
{
// Check if the character before us plus the inserted character(s) makes a template tag
var newText = e.After.GetText(new Span(change.NewSpan.Start - 1, 2));
if (Array.IndexOf(_templateTags, newText) != -1)
{
if (closest != 0)
{
recalcPosition = _spans[--closest].DiskBufferSpan.GetStartPoint(e.After);
}
else
{
recalcPosition = _spans[closest].DiskBufferSpan.GetStartPoint(e.After);
}
recalc = true;
}
}
if (!recalc && change.NewSpan.End >= 2)
{
// check if we inserted template tags at the end
var newText = e.After.GetText(new Span(change.NewSpan.End - 2, 2));
if (Array.IndexOf(_templateTags, newText) != -1)
{
if (closest != 0)
{
recalcPosition = _spans[--closest].DiskBufferSpan.GetStartPoint(e.After);
}
else
{
recalcPosition = _spans[closest].DiskBufferSpan.GetStartPoint(e.After);
}
recalc = true;
}
}
if (!recalc && change.NewSpan.Start + 2 <= e.After.Length)
{
// check if the inserted char plus the char after us makes a template tag
var newText = e.After.GetText(new Span(change.NewSpan.Start, 2));
if (Array.IndexOf(_templateTags, newText) != -1)
{
if (closest != 0)
{
recalcPosition = _spans[--closest].DiskBufferSpan.GetStartPoint(e.After);
}
else
{
recalcPosition = _spans[closest].DiskBufferSpan.GetStartPoint(e.After);
}
recalc = true;
}
}
}
if (!recalc &&
change.NewSpan.Start == closestSpan.DiskBufferSpan.GetStartPoint(e.After) &&
change.NewSpan.Length == 0)
{
// finally, if we are just deleting code (change.NewSpan.Length == 0 indicates there's no insertions) from
// the start of the buffer then we are definitely deleting a } which means we need to re-calc. We know
// we're deleting the } because it's the last char in the buffer before us because it has
// to be the end of a template.
closestSpan = _spans[0];
closest = 0;
recalc = true;
}
}
else
{
// check if the newly inserted text makes a tag, we include the character before
// our span and the character after.
Span changeBounds = change.NewSpan;
if (changeBounds.Start > 0)
{
changeBounds = new Span(changeBounds.Start - 1, changeBounds.Length + 1);
}
if (changeBounds.End < e.After.Length)
{
changeBounds = new Span(changeBounds.Start, changeBounds.Length + 1);
}
var newText = e.After.GetText(changeBounds);
foreach (var tag in _templateTags)
{
if (newText.Contains(tag))
{
recalc = true;
break;
}
}
if (!recalc)
{
var templateStart = closestSpan.DiskBufferSpan.GetStartPoint(e.After);
if (change.NewSpan.Start <= templateStart + 1 ||
change.NewSpan.End == closestSpan.DiskBufferSpan.GetEndPoint(e.After) - 1)
{
// we are altering one of the 1st two characters or the last character.
// Because we're a template that could be messing us up.
// We recalcuate from the previous text buffer
// because the act of deleting this character could have turned us into a text
// buffer, and we need to replace and extend the previous text buffer.
recalcPosition = _spans[--closest].DiskBufferSpan.GetStartPoint(e.After);
recalc = true;
}
}
}
if (recalc)
{
var start = recalcPosition != -1 ? recalcPosition : closestSpan.DiskBufferSpan.GetStartPoint(e.After).Position;
var reader = new SnapshotSpanSourceCodeReader(new SnapshotSpan(e.After, Span.FromBounds(start, e.After.Length)));
UpdateTemplateSpans(reader, closest, start);
}
else if (closestSpan.Kind == TemplateTokenKind.Block)
{
// re-parse the block
_spans[closest] = new SpanInfo(
closestSpan.DiskBufferSpan,
closestSpan.Kind,
DjangoBlock.Parse(closestSpan.DiskBufferSpan.GetText(closestSpan.DiskBufferSpan.TextBuffer.CurrentSnapshot))
);
}
}
else
{
UpdateTemplateSpans(new StringReader(e.After.GetText()));
}
}
}
private static void ValidateIfOrIfNotEqualBlock(DjangoBlock expected, DjangoBlock got) {
var ifExpected = (DjangoIfOrIfNotEqualBlock)expected;
var ifGot = (DjangoIfOrIfNotEqualBlock)got;
Assert.AreEqual(ifExpected.ParseInfo.Start, ifGot.ParseInfo.Start);
Assert.AreEqual(ifExpected.ParseInfo.Command, ifGot.ParseInfo.Command);
Assert.AreEqual(ifExpected.ParseInfo.Args, ifGot.ParseInfo.Args);
}
private static void ValidateSpacelessBlock(DjangoBlock expected, DjangoBlock got) {
var spacelessExpected = (DjangoSpacelessBlock)expected;
var spacelessGot = (DjangoSpacelessBlock)got;
Assert.AreEqual(spacelessExpected.ParseInfo.Start, spacelessGot.ParseInfo.Start);
Assert.AreEqual(spacelessExpected.ParseInfo.Command, spacelessGot.ParseInfo.Command);
Assert.AreEqual(spacelessExpected.ParseInfo.Args, spacelessGot.ParseInfo.Args);
}
private static void ValidateMultiArgumentBlock(DjangoBlock expected, DjangoBlock got) {
var maExpected = (DjangoMultiVariableArgumentBlock)expected;
var maGot = (DjangoMultiVariableArgumentBlock)got;
Assert.AreEqual(maExpected.ParseInfo.Start, maGot.ParseInfo.Start);
Assert.AreEqual(maExpected.ParseInfo.Command, maGot.ParseInfo.Command);
Assert.AreEqual(maExpected.ParseInfo.Args, maGot.ParseInfo.Args);
}
private static void ValidateWidthRatioBlock(DjangoBlock expected, DjangoBlock got) {
var withExpected = (DjangoWidthRatioBlock)expected;
var withGot = (DjangoWidthRatioBlock)got;
Assert.AreEqual(withExpected.ParseInfo.Start, withGot.ParseInfo.Start);
Assert.AreEqual(withExpected.ParseInfo.Command, withGot.ParseInfo.Command);
Assert.AreEqual(withExpected.ParseInfo.Args, withGot.ParseInfo.Args);
}
private static void ValidateTemplateTagBlock(DjangoBlock expected, DjangoBlock got) {
var tempTagExpected = (DjangoTemplateTagBlock)expected;
var tempTagGot = (DjangoTemplateTagBlock)got;
Assert.AreEqual(tempTagExpected.ParseInfo.Start, tempTagGot.ParseInfo.Start);
Assert.AreEqual(tempTagExpected.ParseInfo.Command, tempTagGot.ParseInfo.Command);
Assert.AreEqual(tempTagExpected.ParseInfo.Args, tempTagGot.ParseInfo.Args);
}
public SpanInfo(ITrackingSpan diskBufferSpan, TemplateTokenKind kind, DjangoBlock djangoBlock)
{
DiskBufferSpan = diskBufferSpan;
Kind = kind;
Block = djangoBlock;
}
public SpanInfo(ITrackingSpan diskBufferSpan, TemplateTokenKind kind)
{
DiskBufferSpan = diskBufferSpan;
Kind = kind;
Block = null;
}
private void UpdateTemplateSpans(TextReader reader, int startSpan = 0, int offset = 0)
{
var tokenizer = new TemplateTokenizer(reader);
TemplateToken? token;
List <object> newProjectionSpans = new List <object>(); // spans in the projection buffer
List <SpanInfo> newSpanInfos = new List <SpanInfo>(); // our SpanInfo's, with spans in the on-disk buffer
while ((token = tokenizer.GetNextToken()) != null)
{
var curToken = token.Value;
var sourceSpan = Span.FromBounds(curToken.Start + offset, curToken.End + offset + 1);
switch (curToken.Kind)
{
case TemplateTokenKind.Block:
case TemplateTokenKind.Comment:
case TemplateTokenKind.Variable:
// template spans are setup to not grow. We'll track the edits and update their
// text if something causes them to grow.
if (newSpanInfos.Count == 0 && startSpan == 0)
{
// insert a zero-length span which will grow if the user inserts before the template tag
var emptySpan = new CustomTrackingSpan(
_diskBuffer.CurrentSnapshot,
new Span(0, 0),
PointTrackingMode.Negative,
PointTrackingMode.Positive
);
newProjectionSpans.Add(emptySpan);
newSpanInfos.Add(new SpanInfo(emptySpan, TemplateTokenKind.Text));
}
newSpanInfos.Add(
new SpanInfo(
new CustomTrackingSpan(
_diskBuffer.CurrentSnapshot,
sourceSpan,
PointTrackingMode.Positive,
PointTrackingMode.Negative
),
curToken.Kind,
curToken.Kind == TemplateTokenKind.Block ?
DjangoBlock.Parse(_diskBuffer.CurrentSnapshot.GetText(sourceSpan)) :
null
)
);
newProjectionSpans.Add(
new CustomTrackingSpan(
_templateBuffer.CurrentSnapshot,
sourceSpan,
PointTrackingMode.Positive,
PointTrackingMode.Negative
)
);
break;
case TemplateTokenKind.Text:
var htmlSpan = _htmlBuffer.CurrentSnapshot.Version.CreateCustomTrackingSpan(
sourceSpan,
TrackingFidelityMode.Forward,
new LanguageSpanCustomState(sourceSpan.Start, sourceSpan.End),
TrackToVersion
);
var diskSpan = _diskBuffer.CurrentSnapshot.Version.CreateCustomTrackingSpan(
sourceSpan,
TrackingFidelityMode.Forward,
new LanguageSpanCustomState(sourceSpan.Start, sourceSpan.End),
TrackToVersion
);
newProjectionSpans.Add(htmlSpan);
newSpanInfos.Add(new SpanInfo(diskSpan, TemplateTokenKind.Text));
break;
}
}
if (newSpanInfos.Count == 0 || newSpanInfos[newSpanInfos.Count - 1].Kind != TemplateTokenKind.Text)
{
// insert an empty span at the end which will receive new text.
var emptySpan = _diskBuffer.CurrentSnapshot.Version.CreateCustomTrackingSpan(
new Span(_diskBuffer.CurrentSnapshot.Length, 0),
TrackingFidelityMode.Forward,
new LanguageSpanCustomState(_diskBuffer.CurrentSnapshot.Length, _diskBuffer.CurrentSnapshot.Length),
TrackToVersion
);
newProjectionSpans.Add(emptySpan);
newSpanInfos.Add(new SpanInfo(emptySpan, TemplateTokenKind.Text));
}
var oldSpanCount = _spans.Count;
_spans.RemoveRange(startSpan, oldSpanCount - startSpan);
_spans.AddRange(newSpanInfos);
_projBuffer.ReplaceSpans(startSpan, oldSpanCount - startSpan, newProjectionSpans, _editOptions, null);
ProjectionClassifier classifier;
if (newSpanInfos.Count > 0 &&
_projBuffer.Properties.TryGetProperty <ProjectionClassifier>(typeof(ProjectionClassifier), out classifier))
{
classifier.RaiseClassificationChanged(
newSpanInfos[0].DiskBufferSpan.GetStartPoint(_diskBuffer.CurrentSnapshot),
newSpanInfos[newSpanInfos.Count - 1].DiskBufferSpan.GetEndPoint(_diskBuffer.CurrentSnapshot)
);
}
}
protected override void Reparse(string text) {
Block = DjangoBlock.Parse(text, trim: true);
}
private static void ValidateIfBlock(DjangoBlock expected, DjangoBlock got) {
var ifExpected = (DjangoIfBlock)expected;
var ifGot = (DjangoIfBlock)got;
Assert.AreEqual(ifExpected.ParseInfo.Start, ifGot.ParseInfo.Start);
Assert.AreEqual(ifExpected.ParseInfo.Command, ifGot.ParseInfo.Command);
Assert.AreEqual(ifExpected.ParseInfo.Args, ifGot.ParseInfo.Args);
Assert.AreEqual(ifExpected.Args.Length, ifGot.Args.Length);
for (int i = 0; i < ifExpected.Args.Length; i++) {
Assert.AreEqual(ifExpected.Args[i], ifGot.Args[i]);
}
}
protected override void Reparse(string text)
{
Block = DjangoBlock.Parse(text, trim: true);
}
private static void ValidateUrlBlock(DjangoBlock expected, DjangoBlock got) {
var urlExpected = (DjangoUrlBlock)expected;
var urlGot = (DjangoUrlBlock)got;
Assert.AreEqual(urlExpected.ParseInfo.Start, urlGot.ParseInfo.Start);
Assert.AreEqual(urlExpected.ParseInfo.Command, urlGot.ParseInfo.Command);
Assert.AreEqual(urlExpected.ParseInfo.Args, urlGot.ParseInfo.Args);
Assert.AreEqual(urlExpected.Args.Length, urlGot.Args.Length);
for (int i = 0; i < urlExpected.Args.Length; i++) {
Assert.AreEqual(urlExpected.Args[i], urlGot.Args[i]);
}
}
