Add support for minimized attributes in TagHelpers.

- Updated the Razor parser to understand minimized attributes instead of just treating them like plain text. This just involved encompassing minimized attributes in their own blocks just like the other attributes found on the HTML tag.
- Updated TagHelperParseTreeRewriter to only accept minimized attributes for unbound attributes.
- Updated IReadOnlyTagHelperAttribute/TagHelperAttribute to have a Minimized property to indicate that an attribute was minimized.
- Updated parser level block structures to represent minimized attributes as null syntax tree nodes.
- Updated chunk level structures to represent minimized attributes as null chunks.

#220

Author: N. Taylor Mullen

src/Microsoft.AspNet.Razor.Runtime/TagHelpers/IReadOnlyTagHelperAttribute.cs

@@ -19,5 +19,11 @@ public interface IReadOnlyTagHelperAttribute : IEquatable<IReadOnlyTagHelperAttr
         /// Gets the value of the attribute.
         /// </summary>
         object Value { get; }
+
+        /// <summary>
+        /// Indicates whether the attribute is minimized or not.
+        /// </summary>
+        /// <remarks>If <c>true</c>, <see cref="Value"/> will be ignored.</remarks>
+        bool Minimized { get; }
     }
 }

src/Microsoft.AspNet.Razor.Runtime/TagHelpers/TagHelperAttribute.cs

@@ -41,6 +41,13 @@ public TagHelperAttribute(string name, object value)
         /// </summary>
         public object Value { get; set; }
 
+        /// <summary>
+        /// Gets or sets the value indicating if the attribute is minimized.
+        /// </summary>
+        /// <remarks>If <c>true</c>, <see cref="Value"/> will be ignored.</remarks>
+        public bool Minimized { get; set; }
+
+
         /// <summary>
         /// Converts the specified <paramref name="value"/> into a <see cref="TagHelperAttribute"/>.
         /// </summary>
@@ -61,7 +68,8 @@ public bool Equals(IReadOnlyTagHelperAttribute other)
             return
                 other != null &&
                 string.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase) &&
-                Equals(Value, other.Value);
+                Equals(Value, other.Value) &&
+                Minimized == other.Minimized;
         }
 
         /// <inheritdoc />

src/Microsoft.AspNet.Razor.Runtime/TagHelpers/TagHelperExecutionContext.cs

@@ -39,7 +39,7 @@ internal TagHelperExecutionContext(string tagName, bool selfClosing)
         /// <param name="tagName">The HTML tag name in the Razor source.</param>
         /// <param name="selfClosing">
         /// <see cref="bool"/> indicating whether or not the tag in the Razor source was self-closing.</param>
-        /// <param name="items">The collection of items used to communicate with other 
+        /// <param name="items">The collection of items used to communicate with other
         /// <see cref="ITagHelper"/>s</param>
         /// <param name="uniqueId">An identifier unique to the HTML element this context is for.</param>
         /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param>
@@ -133,6 +133,26 @@ public void Add([NotNull] ITagHelper tagHelper)
             _tagHelpers.Add(tagHelper);
         }
 
+        /// <summary>
+        /// Tracks the minimized HTML attribute in <see cref="AllAttributes"/> and <see cref="HTMLAttributes"/>.
+        /// </summary>
+        /// <param name="name">The minimized HTML attribute name.</param>
+        public void AddHtmlAttribute([NotNull] string name)
+        {
+            HTMLAttributes.Add(
+                new TagHelperAttribute
+                {
+                    Name = name,
+                    Minimized = true
+                });
+            AllAttributes.Add(
+                new TagHelperAttribute
+                {
+                    Name = name,
+                    Minimized = true
+                });
+        }
+
         /// <summary>
         /// Tracks the HTML attribute in <see cref="AllAttributes"/> and <see cref="HTMLAttributes"/>.
         /// </summary>
@@ -168,7 +188,7 @@ public Task ExecuteChildContentAsync()
         /// </summary>
         /// <returns>A <see cref="Task"/> that on completion returns the rendered child content.</returns>
         /// <remarks>
-        /// Child content is only executed once. Successive calls to this method or successive executions of the 
+        /// Child content is only executed once. Successive calls to this method or successive executions of the
         /// returned <see cref="Task{TagHelperContent}"/> return a cached result.
         /// </remarks>
         public async Task<TagHelperContent> GetChildContentAsync()

src/Microsoft.AspNet.Razor/Generator/Compiler/CodeBuilder/CSharp/CSharpTagHelperCodeRenderer.cs

@@ -324,15 +324,21 @@ private void RenderUnboundHTMLAttributes(IEnumerable<KeyValuePair<string, Chunk>
             // Build out the unbound HTML attributes for the tag builder
             foreach (var htmlAttribute in unboundHTMLAttributes)
             {
-                string textValue;
+                string textValue = null;
+                var isPlainTextValue = false;
                 var attributeValue = htmlAttribute.Value;
-                var isPlainTextValue = TryGetPlainTextValue(attributeValue, out textValue);
 
-                // HTML attributes are always strings. So if this value is not plain text i.e. if the value contains
-                // C# code, then we need to buffer it.
-                if (!isPlainTextValue)
+                // A null attribute value means the HTML attribute is minimized.
+                if (attributeValue != null)
                 {
-                    BuildBufferedWritingScope(attributeValue, htmlEncodeValues: true);
+                    isPlainTextValue = TryGetPlainTextValue(attributeValue, out textValue);
+
+                    // HTML attributes are always strings. So if this value is not plain text i.e. if the value contains
+                    // C# code, then we need to buffer it.
+                    if (!isPlainTextValue)
+                    {
+                        BuildBufferedWritingScope(attributeValue, htmlEncodeValues: true);
+                    }
                 }
 
                 // Execution contexts are a runtime feature, therefore no need to add anything to them.
@@ -345,23 +351,28 @@ private void RenderUnboundHTMLAttributes(IEnumerable<KeyValuePair<string, Chunk>
                     .WriteStartInstanceMethodInvocation(
                         ExecutionContextVariableName,
                         _tagHelperContext.ExecutionContextAddHtmlAttributeMethodName)
-                    .WriteStringLiteral(htmlAttribute.Key)
-                    .WriteParameterSeparator()
-                    .WriteStartMethodInvocation(_tagHelperContext.MarkAsHtmlEncodedMethodName);
+                    .WriteStringLiteral(htmlAttribute.Key);
 
-                // If it's a plain text value then we need to surround the value with quotes.
-                if (isPlainTextValue)
+                // If we have a minimized attribute we don't want to provide a value
+                if (attributeValue != null)
                 {
-                    _writer.WriteStringLiteral(textValue);
-                }
-                else
-                {
-                    RenderBufferedAttributeValueAccessor(_writer);
+                    _writer.WriteParameterSeparator()
+                        .WriteStartMethodInvocation(_tagHelperContext.MarkAsHtmlEncodedMethodName);
+
+                    // If it's a plain text value then we need to surround the value with quotes.
+                    if (isPlainTextValue)
+                    {
+                        _writer.WriteStringLiteral(textValue);
+                    }
+                    else
+                    {
+                        RenderBufferedAttributeValueAccessor(_writer);
+                    }
+
+                    _writer.WriteEndMethodInvocation(endLine: false);
                 }
 
-                _writer
-                    .WriteEndMethodInvocation(endLine: false)
-                    .WriteEndMethodInvocation();
+                _writer.WriteEndMethodInvocation();
             }
         }
 

src/Microsoft.AspNet.Razor/Generator/TagHelperCodeGenerator.cs

@@ -57,19 +57,25 @@ public override void GenerateStartBlockCode(Block target, CodeGeneratorContext c
 
             foreach (var attribute in tagHelperBlock.Attributes)
             {
-                // Populates the code tree with chunks associated with attributes
-                attribute.Value.Accept(codeGenerator);
+                ChunkBlock attributeChunkValue = null;
 
-                var chunks = codeGenerator.Context.CodeTreeBuilder.CodeTree.Chunks;
-                var first = chunks.FirstOrDefault();
+                if (attribute.Value != null)
+                {
+                    // Populates the code tree with chunks associated with attributes
+                    attribute.Value.Accept(codeGenerator);
 
-                attributes.Add(new KeyValuePair<string, Chunk>(attribute.Key,
-                    new ChunkBlock
+                    var chunks = codeGenerator.Context.CodeTreeBuilder.CodeTree.Chunks;
+                    var first = chunks.FirstOrDefault();
+
+                    attributeChunkValue = new ChunkBlock
                     {
                         Association = first?.Association,
                         Children = chunks,
                         Start = first == null ? SourceLocation.Zero : first.Start
-                    }));
+                    };
+                }
+
+                attributes.Add(new KeyValuePair<string, Chunk>(attribute.Key, attributeChunkValue));
 
                 // Reset the code tree builder so we can build a new one for the next attribute
                 codeGenerator.Context.CodeTreeBuilder = new CodeTreeBuilder();

src/Microsoft.AspNet.Razor/Parser/HtmlMarkupParser.Block.cs

@@ -316,7 +316,7 @@ private bool EndTag(SourceLocation tagStart,
                 var matched = RemoveTag(tags, tagName, tagStart);
 
                 if (tags.Count == 0 &&
-                    // Note tagName may contain a '!' escape character. This ensures </!text> doesn't match here. 
+                    // Note tagName may contain a '!' escape character. This ensures </!text> doesn't match here.
                     // </!text> tags are treated like any other escaped HTML end tag.
                     string.Equals(tagName, SyntaxConstants.TextTagName, StringComparison.OrdinalIgnoreCase) &&
                     matched)
@@ -471,11 +471,21 @@ private void BeforeAttribute()
                 return;
             }
 
+            // Minimized attribute
+            // Need to modify this code to account for space inbetween equals when
+            // https://github.com/aspnet/Razor/issues/123 is completed.
             if (!At(HtmlSymbolType.Equals))
             {
-                // Saw a space or newline after the name, so just skip this attribute and continue around the loop
-                Accept(whitespace);
-                Accept(name);
+                // Output anything prior to the attribute, in most cases this will be the tag name:
+                // |<input| checked />
+                Output(SpanKind.Markup);
+                using (Context.StartBlock(BlockType.Markup))
+                {
+                    Accept(whitespace);
+                    Accept(name);
+                    Output(SpanKind.Markup);
+                }
+
                 return;
             }
 
@@ -719,7 +729,7 @@ private bool StartTag(Stack<Tuple<HtmlSymbol, SourceLocation>> tags, IDisposable
             Tuple<HtmlSymbol, SourceLocation> tag = Tuple.Create(tagName, _lastTagStart);
 
             if (tags.Count == 0 &&
-                // Note tagName may contain a '!' escape character. This ensures <!text> doesn't match here. 
+                // Note tagName may contain a '!' escape character. This ensures <!text> doesn't match here.
                 // <!text> tags are treated like any other escaped HTML start tag.
                 string.Equals(tag.Item1.Content, SyntaxConstants.TextTagName, StringComparison.OrdinalIgnoreCase))
             {

src/Microsoft.AspNet.Razor/Parser/TagHelpers/TagHelperBlock.cs

@@ -38,7 +38,10 @@ public TagHelperBlock(TagHelperBlockBuilder source)
 
             foreach (var attributeChildren in Attributes)
             {
-                attributeChildren.Value.Parent = this;
+                if (attributeChildren.Value != null)
+                {
+                    attributeChildren.Value.Parent = this;
+                }
             }
         }
 

src/Microsoft.AspNet.Razor/Parser/TagHelpers/TagHelperBlockRewriter.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -71,11 +71,12 @@ private static IList<KeyValuePair<string, SyntaxTreeNode>> GetTagAttributes(
                 // Only want to track the attribute if we succeeded in parsing its corresponding Block/Span.
                 if (succeeded)
                 {
-                    // Check if it's a bound attribute that is not of type string and happens to be null or whitespace.
+                    // Check if it's a bound attribute that is minimized or not of type string and null or whitespace.
                     string attributeValueType;
                     if (attributeValueTypes.TryGetValue(attribute.Key, out attributeValueType) &&
+                        (attribute.Value == null ||
                         !IsStringAttribute(attributeValueType) &&
-                        IsNullOrWhitespaceAttributeValue(attribute.Value))
+                        IsNullOrWhitespaceAttributeValue(attribute.Value)))
                     {
                         var errorLocation = GetAttributeNameStartLocation(child);
 
@@ -167,7 +168,7 @@ private static bool TryParseSpan(
                 {
                     Debug.Assert(
                         name != null,
-                        "Name should never be null here. The parser should guaruntee an attribute has a name.");
+                        "Name should never be null here. The parser should guarantee an attribute has a name.");
 
                     // We've captured all leading whitespace and the attribute name.
                     // We're now at: " asp-for|='...'" or " asp-for|=..."
@@ -239,7 +240,10 @@ private static bool TryParseSpan(
                 return false;
             }
 
-            attribute = CreateMarkupAttribute(name, builder, attributeValueTypes);
+            // If we're not after an equal then we should treat the value as if it were a minimized attribute.
+            // Aka null value.
+            var attributeValueBuilder = afterEquals ? builder : null;
+            attribute = CreateMarkupAttribute(name, attributeValueBuilder, attributeValueTypes);
 
             return true;
         }
@@ -431,17 +435,24 @@ private static KeyValuePair<string, SyntaxTreeNode> CreateMarkupAttribute(
             IReadOnlyDictionary<string, string> attributeValueTypes)
         {
             string attributeTypeName;
+            Span value = null;
 
-            // If the attribute was requested by the tag helper and doesn't happen to be a string then we need to treat
-            // its value as code. Any non-string value can be any C# value so we need to ensure the SyntaxTreeNode
-            // reflects that.
-            if (attributeValueTypes.TryGetValue(name, out attributeTypeName) &&
-                !IsStringAttribute(attributeTypeName))
+            // Builder will be null in the case of minimized attributes
+            if (builder != null)
             {
-                builder.Kind = SpanKind.Code;
+                // If the attribute was requested by the tag helper and doesn't happen to be a string then we need to treat
+                // its value as code. Any non-string value can be any C# value so we need to ensure the SyntaxTreeNode
+                // reflects that.
+                if (attributeValueTypes.TryGetValue(name, out attributeTypeName) &&
+                    !IsStringAttribute(attributeTypeName))
+                {
+                    builder.Kind = SpanKind.Code;
+                }
+
+                value = builder.Build();
             }
 
-            return new KeyValuePair<string, SyntaxTreeNode>(name, builder.Build());
+            return new KeyValuePair<string, SyntaxTreeNode>(name, value);
         }
 
         private static bool IsNullOrWhitespaceAttributeValue(SyntaxTreeNode attributeValue)