protected override SyntaxTreeNode RewriteSpan (BlockBuilder parent, Span span) { var b = new SpanBuilder (span); var old = (LiteralAttributeCodeGenerator)span.CodeGenerator; b.CodeGenerator = old.ValueGenerator != null ? new PreprocessedLiteralAttributeCodeGenerator (old.Prefix, old.ValueGenerator) : new PreprocessedLiteralAttributeCodeGenerator (old.Prefix, old.Value); return b.Build (); }
protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block) { // Collect the content of this node string content = String.Concat(block.Children.Cast<Span>().Select(s => s.Content)); // Create a new span containing this content SpanBuilder span = new SpanBuilder(); FillSpan(span, block.Children.Cast<Span>().First().Start, content); return span.Build(); }
public void ConstructorWithBlockBuilderSetsParent() { // Arrange BlockBuilder builder = new BlockBuilder() { Type = BlockType.Comment }; Span span = new SpanBuilder() { Kind = SpanKind.Code }.Build(); builder.Children.Add(span); // Act Block block = builder.Build(); // Assert Assert.Same(block, span.Parent); }
public override void VisitSpan(Span span) { if (span.Kind == SpanKind.Markup && !m_DebugStatusReader.IsDebuggingEnabled()) { string content = m_HtmlPageMinifier.Minify(span.Content, true, true); SpanBuilder builder = new SpanBuilder { CodeGenerator = span.CodeGenerator, EditHandler = span.EditHandler, Kind = span.Kind, Start = span.Start }; MarkupSymbol symbol = new MarkupSymbol { Content = content }; builder.Accept(symbol); span.ReplaceWith(builder); } base.VisitSpan(span); }
protected override SyntaxTreeNode RewriteSpan(BlockBuilder parent, Span span) { // Only rewrite if we have a previous that is also markup (CanRewrite does this check for us!) Span previous = parent.Children.LastOrDefault() as Span; if (previous == null || !CanRewrite(previous)) { return span; } // Merge spans parent.Children.Remove(previous); SpanBuilder merged = new SpanBuilder(); FillSpan(merged, previous.Start, previous.Content + span.Content); return merged.Build(); }
public void ConstructorTransfersChildrenFromBlockBuilder() { // Arrange Span expected = new SpanBuilder() { Kind = SpanKind.Code }.Build(); BlockBuilder builder = new BlockBuilder() { Type = BlockType.Functions }; builder.Children.Add(expected); // Act Block block = builder.Build(); // Assert Assert.Same(expected, block.Children.Single()); }
public void ReplaceWith(SpanBuilder builder) { Debug.Assert(!builder.Symbols.Any() || builder.Symbols.All(s => s != null)); Kind = builder.Kind; Symbols = builder.Symbols; EditHandler = builder.EditHandler; CodeGenerator = builder.CodeGenerator ?? SpanCodeGenerator.Null; _start = builder.Start; // Since we took references to the values in SpanBuilder, clear its references out builder.Reset(); // Calculate other properties Content = Symbols.Aggregate(new StringBuilder(), (sb, sym) => sb.Append(sym.Content), sb => sb.ToString()); }
protected virtual SpanBuilder UpdateSpan(Span target, TextChange normalizedChange) { string newContent = normalizedChange.ApplyChange(target); SpanBuilder newSpan = new SpanBuilder(target); newSpan.ClearSymbols(); foreach (ISymbol sym in Tokenizer(newContent)) { sym.OffsetStart(target.Start); newSpan.Accept(sym); } if (target.Next != null) { SourceLocation newEnd = SourceLocationTracker.CalculateNewLocation(target.Start, newContent); target.Next.ChangeStart(newEnd); } return newSpan; }
public override void VisitSpan(Span span) { if (span.Kind == SpanKind.Markup) { string content = span.Content; content = _minifier.Minify(content); // We replace the content with the minified markup // and then let the CSharp/VB generator do their jobs. var builder = new SpanBuilder { CodeGenerator = span.CodeGenerator, EditHandler = span.EditHandler, Kind = span.Kind, Start = span.Start }; var symbol = new MarkupSymbol { Content = content }; builder.Accept(symbol); span.ReplaceWith(builder); } base.VisitSpan(span); }
public void ReplaceWith(SpanBuilder builder) { Debug.Assert(!builder.Symbols.Any() || builder.Symbols.All(s => s != null)); Kind = builder.Kind; Symbols = builder.Symbols; EditHandler = builder.EditHandler; CodeGenerator = builder.CodeGenerator ?? SpanCodeGenerator.Null; _start = builder.Start; // Since we took references to the values in SpanBuilder, clear its references out builder.Reset(); // Calculate other properties Content = Symbols.Aggregate( new StringBuilder(), (sb, sym) => sb.Append(sym.Content), sb => sb.ToString() ); }
//public override void VisitBlock(Block block) //{ // BlockBuilder parent = null; // if (_blocks.Count > 0) // { // parent = _blocks.Peek(); // } // BlockBuilder newBlock = new BlockBuilder(block); // newBlock.Children.Clear(); // _blocks.Push(newBlock); // if (block.Type == BlockType.Expression && parent != null) // { // VisitExpressionBlock(block, parent); // } // else // { // base.VisitBlock(block); // } // if (_blocks.Count > 1) // { // parent.Children.Add(_blocks.Pop().Build()); // } //} //public override void VisitSpan(Span span) //{ // Debug.Assert(_blocks.Count > 0); // _blocks.Peek().Children.Add(span); //} protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block) { BlockBuilder newBlock = new BlockBuilder(block); newBlock.Children.Clear(); Span ws = block.Children.FirstOrDefault() as Span; IEnumerable<SyntaxTreeNode> newNodes = block.Children; if (ws.Content.All(Char.IsWhiteSpace)) { // Add this node to the parent SpanBuilder builder = new SpanBuilder(ws); builder.ClearSymbols(); FillSpan(builder, ws.Start, ws.Content); parent.Children.Add(builder.Build()); // Remove the old whitespace node newNodes = block.Children.Skip(1); } foreach (SyntaxTreeNode node in newNodes) { newBlock.Children.Add(node); } return newBlock.Build(); }
private void MinifyMarkup(BlockBuilder block) { var codeGenerator = new MarkupCodeGenerator(); var previousIsWhiteSpace = true; var previousTokenEndsWithBlockElement = true; for (int i = 0; i < block.Children.Count; i++) { var node = block.Children[i]; var span = node as Span; if (span == null) { // When we have a dynamic markup, we can't know if the last char will be whitespace // => to make it work in all cases, we won't minifiy whitespace just after code. previousIsWhiteSpace = false; previousTokenEndsWithBlockElement = false; continue; } // There may be several HTML tokens just one after the other. // => we concatenate everything in a single token to minify everyting in a single scan // (we is better for Javascript minification). var sb = new StringBuilder(); sb.Append(span.Content); if (i < block.Children.Count - 1) { var markup = block.Children[i + 1] as Span; while ((markup != null) && (markup.Kind == SpanKind.Markup) && ((markup.Next == null) || ((markup.Next != null) && ((markup.Next.Kind == SpanKind.Markup) || ((markup.Next.Kind != SpanKind.Markup) && !markup.Content.EndsWith("\"")))))) { block.Children.RemoveAt(i + 1); sb.Append(markup.Content); markup = i + 1 < block.Children.Count ? block.Children[i + 1] as Span : null; } } var content = sb.ToString(); if (string.IsNullOrEmpty(content)) { // Nothing to minify block.Children.RemoveAt(i); continue; } content = _minifier.Minify(content, previousIsWhiteSpace, previousTokenEndsWithBlockElement); _minifier.AnalyseContent(content, ref previousIsWhiteSpace, ref previousTokenEndsWithBlockElement); // We replace the content with the minified markup // and then let the CSharp/VB generator do their jobs. var builder = new SpanBuilder() { CodeGenerator = codeGenerator, EditHandler = span.EditHandler, Kind = span.Kind, Start = span.Start }; var symbol = new MarkupSymbol() { Content = content }; builder.Accept(symbol); span.ReplaceWith(builder); } }
protected void FillSpan(SpanBuilder builder, SourceLocation start, string content) { _markupSpanFactory(builder, start, content); }
public void AddSpanAddsSpanToCurrentBlockBuilder() { // Arrange var factory = SpanFactory.CreateCsHtml(); Mock<ParserVisitor> mockListener = new Mock<ParserVisitor>(); ParserContext context = SetupTestContext("phoo"); SpanBuilder builder = new SpanBuilder() { Kind = SpanKind.Code }; builder.Accept(new CSharpSymbol(1, 0, 1, "foo", CSharpSymbolType.Identifier)); Span added = builder.Build(); using (context.StartBlock(BlockType.Functions)) { context.AddSpan(added); } BlockBuilder expected = new BlockBuilder() { Type = BlockType.Functions, }; expected.Children.Add(added); // Assert ParserTestBase.EvaluateResults(context.CompleteParse(), expected.Build()); }
public override void BuildSpan(SpanBuilder span, Razor.Text.SourceLocation start, string content) { throw new NotImplementedException(); }
public abstract void BuildSpan(SpanBuilder span, SourceLocation start, string content);
public EditResult(PartialParseResult result, SpanBuilder editedSpan) { Result = result; EditedSpan = editedSpan; }
public Span(SpanBuilder builder) { ReplaceWith(builder); }
public void Change(Action<SpanBuilder> changes) { SpanBuilder builder = new SpanBuilder(this); changes(builder); ReplaceWith(builder); }
public Span(SpanBuilder builder) { ReplaceWith(builder); }
public SpanConstructor(SpanKind kind, IEnumerable<ISymbol> symbols) { Builder = new SpanBuilder(); Builder.Kind = kind; Builder.EditHandler = SpanEditHandler.CreateDefault(TestTokenizer); foreach (ISymbol sym in symbols) { Builder.Accept(sym); } }
private void DefaultMarkupSpan(SpanBuilder span) { span.CodeGenerator = new MarkupCodeGenerator(); span.EditHandler = new SpanEditHandler(Language.TokenizeString, AcceptedCharacters.Any); }
public override void BuildSpan(System.Web.Razor.Parser.SyntaxTree.SpanBuilder span, System.Web.Razor.Text.SourceLocation start, string content) { _other.BuildSpan(span, start, content); }