private void WriteAttributeTest( string name, PositionTagged <string> prefix, PositionTagged <string> suffix, AttributeValue[] values, string expected ) { // Arrange var pageMock = new Mock <WebPageExecutingBase>() { CallBase = true }; pageMock.Setup(p => p.Context).Returns(new Mock <HttpContextBase>().Object); pageMock.Object.InstrumentationService.IsAvailable = false; StringBuilder written = new StringBuilder(); StringWriter writer = new StringWriter(written); // Act pageMock.Object.WriteAttributeTo(writer, name, prefix, suffix, values); // Assert Assert.Equal(expected, written.ToString()); }
protected new void WriteAttribute(string attribute, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { // skip null attributes if (values == null || values.All(v => v.Value.Value == null)) { return; } // special processing for booleans if (values.Length == 1) { var value = values[0].Value.Value; if (value.Equals(false)) { return; } if (value.Equals(true)) { base.Write(attribute); return; } } base.Write(prefix.Value); foreach (var attributeValue in values) { base.Write(attributeValue.Prefix.Value); //System.Diagnostics.Debugger.Launch(); this.WriteAttributeValue(attributeValue.Value.Value); } base.Write(suffix.Value); }
/// <summary> /// Writes an attribute to the result. /// </summary> /// <param name="name">The name of the attribute.</param> public virtual void WriteAttribute(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WriteLiteral( prefix); WriteLiteral(suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged<object> val = attrVal.Value; bool? boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; if (valStr == null) { valStr = val.Value.ToString(); } if (boolVal != null) { Debug.Assert(boolVal.Value); valStr = name; } if (first) { WriteLiteral( prefix); first = false; } else { WriteLiteral( attrVal.Prefix); } if (attrVal.Literal) { WriteLiteral( valStr); } else { WriteLiteral( valStr); // Write value } wroteSomething = true; } } if (wroteSomething) { WriteLiteral( suffix); } } }
private void WritePositionTaggedLiteral( TextWriter writer, string pageVirtualPath, PositionTagged <string> value ) { WritePositionTaggedLiteral(writer, pageVirtualPath, value.Value, value.Position); }
private void WritePositionTaggedLiteral(PositionTagged <string> value) { if (value.Value == null) { return; } this.WriteLiteral(value.Value); }
public override void WriteAttribute(string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { values = values.Select(val => new AttributeValue( val.Prefix, new PositionTagged <object>(FilterValue(val.Value.Value), val.Value.Position), val.Literal)).ToArray(); base.WriteAttribute(name, prefix, suffix, values); }
private void WriteAttributeTest( string name, PositionTagged <string> prefix, PositionTagged <string> suffix, string expected ) { WriteAttributeTest(name, prefix, suffix, new AttributeValue[0], expected); }
public virtual void WriteAttribute(string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params HtmlAttributeValue[] values) { Writer.Write(prefix.Value); foreach (HtmlAttributeValue av in values) { Writer.Write(av.Value.Value); } Writer.Write(suffix.Value); }
public virtual void WriteAttribute( string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values ) { WriteAttributeTo(GetOutputWriter(), name, prefix, suffix, values); }
public AttributeValue( PositionTagged <string> prefix, PositionTagged <object> value, bool literal ) { Prefix = prefix; Value = value; Literal = literal; }
public static void WriteAttributeTo( TextWriter writer, string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values ) { CurrentPage.WriteAttributeTo(VirtualPath, writer, name, prefix, suffix, values); }
public virtual void WriteAttribute(string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { bool flag = true; bool flag1 = false; if (values.Length == 0) { this.WritePositionTaggedLiteral(prefix); this.WritePositionTaggedLiteral(suffix); return; } AttributeValue[] attributeValueArray = values; for (int i = 0; i < (int)attributeValueArray.Length; i++) { AttributeValue attributeValue = attributeValueArray[i]; PositionTagged <object> value = attributeValue.Value; bool?nullable = null; if (value.Value is bool) { nullable = new bool?((bool)value.Value); } if (value.Value != null && (!nullable.HasValue || nullable.Value)) { string str = value.Value as string ?? value.Value.ToString(); if (nullable.HasValue) { str = name; } if (!flag) { this.WritePositionTaggedLiteral(attributeValue.Prefix); } else { this.WritePositionTaggedLiteral(prefix); flag = false; } if (!attributeValue.Literal) { this.Write(str); } else { this.WriteLiteral(str); } flag1 = true; } } if (flag1) { this.WritePositionTaggedLiteral(suffix); } }
protected new void WriteAttribute(string attribute, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { base.Write(prefix.Value); if (values != null) { foreach (var attributeValue in values) { base.Write(attributeValue.Prefix.Value); var obj = attributeValue.Value.Value; this.Write(obj); } } base.Write(suffix.Value); }
/// <summary> /// Razor 2.0 /// Writes attribute in situations like <img src="@Model">. /// </summary> protected void WriteAttribute( string attribute, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { _buffer.Append(prefix.Value); if (values != null) { foreach (var attributeValue in values) { _buffer.Append(attributeValue.Prefix.Value); var value = attributeValue.Value.Value; if (value != null) { _buffer.Append(value); } } } _buffer.Append(suffix.Value); }
/// <summary> /// Razor 2.0 /// Writes attribute in situations like <img src="@Model">. /// </summary> protected void WriteAttribute( string attribute, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { _buffer.Append(prefix.Value); if (values != null) { foreach (var attributeValue in values) { _buffer.Append(attributeValue.Prefix.Value); var value = attributeValue.Value.Value; if (value != null) { _buffer.Append(value); } } } _buffer.Append(suffix.Value); }
private void WriteAttributeTest(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, string expected) { WriteAttributeTest(name, prefix, suffix, new AttributeValue[0], expected); }
/// WriteAttribute implementation lifted from ANurse's MicroRazor Implementation and the AspWebStack source /// <summary> /// Writes the specified attribute to the template. /// </summary> /// <param name="name">The attribute name.</param> /// <param name="prefix">The attribute prefix.</param> /// <param name="suffix">The attribute suffix.</param> /// <param name="values">The attribute values.</param> public virtual void WriteAttribute(string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { var first = true; var wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix this.WritePositionTaggedLiteral(prefix); this.WritePositionTaggedLiteral(suffix); } else { for (var i = 0; i < values.Length; i++) { var attrVal = values[i]; var val = attrVal.Value; bool?boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { var valStr = val.Value as string; if (valStr == null) { valStr = val.Value.ToString(); } if (boolVal != null) { valStr = name; } if (first) { this.WritePositionTaggedLiteral(prefix); first = false; } else { this.WritePositionTaggedLiteral(attrVal.Prefix); } if (attrVal.Literal) { this.WriteLiteral(valStr); } else { this.Write(valStr); } wroteSomething = true; } } if (wroteSomething) { this.WritePositionTaggedLiteral(suffix); } } }
/// <summary> /// Writes an attribute to the specified <see cref="TextWriter"/>. /// </summary> /// <param name="writer">The writer.</param> /// <param name="name">The name of the attribute to be written.</param> /// <param name="prefix"></param> /// <param name="suffix"></param> /// <param name="values"></param> public virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, prefix); WritePositionTaggedLiteral(writer, suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged <object> val = attrVal.Value; bool?boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; string valToString = valStr; if (valStr == null) { valToString = val.Value.ToString(); } if (boolVal != null) { Debug.Assert(boolVal.Value); valToString = name; } if (first) { WritePositionTaggedLiteral(writer, prefix); first = false; } else { WritePositionTaggedLiteral(writer, attrVal.Prefix); } if (attrVal.Literal) { WriteLiteralTo(writer, valToString); } else { if (val.Value is IEncodedString && boolVal == null) { WriteTo(writer, val.Value); // Write value } else { WriteTo(writer, valToString); // Write value } } wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, suffix); } } }
/// <summary> /// Writes an attribute to the result. /// </summary> /// <param name="name">The name of the attribute.</param> public virtual void WriteAttribute(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { WriteAttributeTo(CurrentWriter, name, prefix, suffix, values); }
public void WriteAttributeTo_WritesAsExpected(AttributeValue[] attributeValues, string expectedOutput) { // Arrange var page = CreatePage(p => { }); page.HtmlEncoder = new CommonTestEncoder(); var writer = new StringWriter(); var prefix = new PositionTagged<string>("someattr=", 0); var suffix = new PositionTagged<string>(string.Empty, 0); // Act page.WriteAttributeTo(writer, "someattr", prefix, suffix, attributeValues); // Assert Assert.Equal(expectedOutput, writer.ToString()); }
private void WritePositionTaggedLiteral(TextWriter writer, string pageVirtualPath, PositionTagged<string> value) { WritePositionTaggedLiteral(writer, pageVirtualPath, value.Value, value.Position); }
public virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { WriteAttributeTo(VirtualPath, writer, name, prefix, suffix, values); }
protected internal virtual void WriteAttributeTo(string pageVirtualPath, TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } else { foreach (AttributeValue attrVal in values) { PositionTagged<object> val = attrVal.Value; bool? boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; if (valStr == null) { valStr = val.Value.ToString(); } if (boolVal != null) { Debug.Assert(boolVal.Value); valStr = name; } if (first) { WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); first = false; } else { WritePositionTaggedLiteral(writer, pageVirtualPath, attrVal.Prefix); } BeginContext(writer, pageVirtualPath, attrVal.Value.Position, valStr.Length, isLiteral: attrVal.Literal); if (attrVal.Literal) { WriteLiteralTo(writer, valStr); } else { WriteTo(writer, valStr); // Write value } EndContext(writer, pageVirtualPath, attrVal.Value.Position, valStr.Length, isLiteral: attrVal.Literal); wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } } }
/// <summary> /// Writes an attribute to the specified <see cref="TextWriter"/>. /// </summary> /// <param name="writer">The writer.</param> /// <param name="name">The name of the attribute to be written.</param> /// <param name="prefix"></param> /// <param name="suffix"></param> /// <param name="values"></param> public virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { if (writer == null) throw new ArgumentNullException(nameof(writer)); bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, prefix); WritePositionTaggedLiteral(writer, suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged<object> val = attrVal.Value; bool? boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; string valToString = valStr; if (valStr == null) { valToString = val.Value.ToString(); } if (boolVal != null) { Debug.Assert(boolVal.Value); valToString = name; } if (first) { WritePositionTaggedLiteral(writer, prefix); first = false; } else { WritePositionTaggedLiteral(writer, attrVal.Prefix); } if (attrVal.Literal) { WriteLiteralTo(writer, valToString); } else { if (val.Value is IEncodedString && boolVal == null) { WriteTo(writer, val.Value); // Write value } else { WriteTo(writer, valToString); // Write value } } wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, suffix); } } }
private void WritePositionTaggedLiteral(PositionTagged <string> value) { this.WritePositionTaggedLiteral(value.Value); }
/// <summary>Writes a <see cref="PositionTagged{string}" /> literal to the result.</summary> /// <param name="value">The value.</param> private void WritePositionTaggedLiteral(PositionTagged<string> value) { WriteLiteral(value.Value); }
/// <summary> /// Writes an attribute to the current <see cref="Writer"/>. /// </summary> /// <param name="writer">The writer.</param> /// <param name="name">The name.</param> /// <param name="prefix">The prefix.</param> /// <param name="suffix">The suffix.</param> /// <param name="values">The values.</param> /// <exception cref="System.ArgumentNullException">writer</exception> public virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { if (writer == null) throw new ArgumentNullException("writer"); bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, prefix); WritePositionTaggedLiteral(writer, suffix); } else { for (int i = 0; i < values.Length; i++) { var attrVal = values[i]; var val = attrVal.Value; var next = i == values.Length - 1 ? suffix : // End of the list, grab the suffix values[i + 1].Prefix; // Still in the list, grab the next prefix bool? boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; if (valStr == null) { valStr = val.Value.ToString(); } if (boolVal != null) { Debug.Assert(boolVal.Value); valStr = name; } if (first) { WritePositionTaggedLiteral(writer, prefix); first = false; } else { WritePositionTaggedLiteral(writer, attrVal.Prefix); } if (attrVal.Literal) { WriteLiteralTo(writer, valStr); } else { WriteTo(writer, valStr); // Write value } wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, suffix); } } }
private void WriteAttributeTest(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, AttributeValue[] values, string expected) { // Arrange var pageMock = new Mock<WebPageExecutingBase>() { CallBase = true }; pageMock.Setup(p => p.Context).Returns(new Mock<HttpContextBase>().Object); pageMock.Object.InstrumentationService.IsAvailable = false; StringBuilder written = new StringBuilder(); StringWriter writer = new StringWriter(written); // Act pageMock.Object.WriteAttributeTo(writer, name, prefix, suffix, values); // Assert Assert.Equal(expected, written.ToString()); }
//https://gist.github.com/anurse/4036121 //http://stackoverflow.com/questions/12321616/why-is-mvc-4-razor-escaping-ampersand-when-using-html-raw-in-a-title-attribute /// <summary>Fixed MVC 4 bug <div [email protected]("\"A&B\") to render correctly <div title="A&B"</summary><param name="pageVirtualPath"></param><param name="writer"></param><param name="name"></param><param name="prefix"></param><param name="suffix"></param><param name="values"></param> protected override void WriteAttributeTo(string pageVirtualPath, TextWriter writer, string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged <object> val = attrVal.Value; PositionTagged <string> next = i == values.Length - 1 ? suffix : // End of the list, grab the suffix values[i + 1].Prefix; // Still in the list, grab the next prefix bool?boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; // This shouldn't be needed any more //if (valStr == null) //{ // valStr = val.Value.ToString(); //} if (boolVal != null) { valStr = name; } if (first) { WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); first = false; } else { WritePositionTaggedLiteral(writer, pageVirtualPath, attrVal.Prefix); } // Calculate length of the source span by the position of the next value (or suffix) int sourceLength = next.Position - attrVal.Value.Position; BeginContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); if (attrVal.Literal) { WriteLiteralTo(writer, val.Value); } else { // Patch: Don't use valStr, use val.Value WriteTo(writer, val.Value); // Write value } EndContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } } }
protected internal virtual void WriteAttributeTo(string pageVirtualPath, TextWriter writer, string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged <object> val = attrVal.Value; PositionTagged <string> next = i == values.Length - 1 ? suffix : // End of the list, grab the suffix values[i + 1].Prefix; // Still in the list, grab the next prefix if (val.Value == null) { // Nothing to write continue; } // The special cases here are that the value we're writing might already be a string, or that the // value might be a bool. If the value is the bool 'true' we want to write the attribute name instead // of the string 'true'. If the value is the bool 'false' we don't want to write anything. // // Otherwise the value is another object (perhaps an IHtmlString), and we'll ask it to format itself. string stringValue; bool? boolValue = val.Value as bool?; if (boolValue == true) { stringValue = name; } else if (boolValue == false) { continue; } else { stringValue = val.Value as string; } if (first) { WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); first = false; } else { WritePositionTaggedLiteral(writer, pageVirtualPath, attrVal.Prefix); } // Calculate length of the source span by the position of the next value (or suffix) int sourceLength = next.Position - attrVal.Value.Position; BeginContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); if (attrVal.Literal) { WriteLiteralTo(writer, stringValue ?? val.Value); } else { WriteTo(writer, stringValue ?? val.Value); // Write value } EndContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); wroteSomething = true; } if (wroteSomething) { WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } } }
protected internal virtual void WriteAttributeTo(string pageVirtualPath, TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged<object> val = attrVal.Value; PositionTagged<string> next = i == values.Length - 1 ? suffix : // End of the list, grab the suffix values[i + 1].Prefix; // Still in the list, grab the next prefix if (val.Value == null) { // Nothing to write continue; } // The special cases here are that the value we're writing might already be a string, or that the // value might be a bool. If the value is the bool 'true' we want to write the attribute name instead // of the string 'true'. If the value is the bool 'false' we don't want to write anything. // // Otherwise the value is another object (perhaps an IHtmlString), and we'll ask it to format itself. string stringValue; bool? boolValue = val.Value as bool?; if (boolValue == true) { stringValue = name; } else if (boolValue == false) { continue; } else { stringValue = val.Value as string; } if (first) { WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); first = false; } else { WritePositionTaggedLiteral(writer, pageVirtualPath, attrVal.Prefix); } // Calculate length of the source span by the position of the next value (or suffix) int sourceLength = next.Position - attrVal.Value.Position; BeginContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); if (attrVal.Literal) { WriteLiteralTo(writer, stringValue ?? val.Value); } else { WriteTo(writer, stringValue ?? val.Value); // Write value } EndContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); wroteSomething = true; } if (wroteSomething) { WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } } }
/// <summary>Writes an attribute to the result.</summary> /// <param name="name">The name of the attribute.</param> /// <param name="prefix"></param> /// <param name="suffix"></param> /// <param name="values"></param> public virtual void WriteAttribute(string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { this.WriteAttributeTo(this.CurrentWriter, name, prefix, suffix, values); }
protected internal virtual void WriteAttributeTo(string pageVirtualPath, TextWriter writer, string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } else { foreach (AttributeValue attrVal in values) { PositionTagged <object> val = attrVal.Value; bool?boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; if (valStr == null) { valStr = val.Value.ToString(); } if (boolVal != null) { Debug.Assert(boolVal.Value); valStr = name; } if (first) { WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); first = false; } else { WritePositionTaggedLiteral(writer, pageVirtualPath, attrVal.Prefix); } BeginContext(writer, pageVirtualPath, attrVal.Value.Position, valStr.Length, isLiteral: attrVal.Literal); if (attrVal.Literal) { WriteLiteralTo(writer, valStr); } else { WriteTo(writer, valStr); // Write value } EndContext(writer, pageVirtualPath, attrVal.Value.Position, valStr.Length, isLiteral: attrVal.Literal); wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } } }
/// <summary> /// Writes an attribute to the specified <see cref="T:System.IO.TextWriter" />. /// </summary> /// <param name="writer">The writer.</param> /// <param name="name">The name of the attribute to be written.</param> /// <param name="prefix"></param> /// <param name="suffix"></param> /// <param name="values"></param> public virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged <string> prefix, PositionTagged <string> suffix, params AttributeValue[] values) { var flag1 = true; var flag2 = false; if (values.Length == 0) { this.WritePositionTaggedLiteral(writer, prefix); this.WritePositionTaggedLiteral(writer, suffix); } else { foreach (var attributeValue in values) { var positionTagged = attributeValue.Value; var nullable = new bool?(); if (positionTagged.Value is bool) { nullable = (bool)positionTagged.Value; } if (positionTagged.Value != null && (!nullable.HasValue || nullable.Value)) { string literal; if ((literal = positionTagged.Value as string) == null) { literal = positionTagged.Value.ToString(); } if (nullable.HasValue) { literal = name; } if (flag1) { this.WritePositionTaggedLiteral(writer, prefix); flag1 = false; } else { this.WritePositionTaggedLiteral(writer, attributeValue.Prefix); } if (attributeValue.Literal) { this.WriteLiteralTo(writer, literal); } else if (positionTagged.Value is IEncodedString) { this.WriteTo(writer, positionTagged.Value); } else { this.WriteTo(writer, literal); } flag2 = true; } } if (!flag2) { return; } this.WritePositionTaggedLiteral(writer, suffix); } }
public AttributeValue(PositionTagged<string> prefix, PositionTagged<object> value, bool literal) { Prefix = prefix; Value = value; Literal = literal; }
public virtual void WriteAttribute(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params HtmlAttributeValue[] values) { Writer.Write(prefix.Value); foreach (HtmlAttributeValue av in values) { Writer.Write(av.Value.Value); } Writer.Write(suffix.Value); }
/// <summary> /// Writes a <see cref="PositionTagged{string}" /> literal to the result. /// </summary> /// <param name="writer">The writer.</param> /// <param name="literal">The literal to be written.</param> private void WritePositionTaggedLiteral(TextWriter writer, PositionTagged<string> value) { WriteLiteralTo(writer, value.Value); }
//https://gist.github.com/anurse/4036121 //http://stackoverflow.com/questions/12321616/why-is-mvc-4-razor-escaping-ampersand-when-using-html-raw-in-a-title-attribute /// <summary>Fixed MVC 4 bug <div [email protected]("\"A&B\") to render correctly <div title="A&B"</summary><param name="pageVirtualPath"></param><param name="writer"></param><param name="name"></param><param name="prefix"></param><param name="suffix"></param><param name="values"></param> protected override void WriteAttributeTo(string pageVirtualPath, TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged<object> val = attrVal.Value; PositionTagged<string> next = i == values.Length - 1 ? suffix : // End of the list, grab the suffix values[i + 1].Prefix; // Still in the list, grab the next prefix bool? boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; // This shouldn't be needed any more //if (valStr == null) //{ // valStr = val.Value.ToString(); //} if (boolVal != null) { valStr = name; } if (first) { WritePositionTaggedLiteral(writer, pageVirtualPath, prefix); first = false; } else { WritePositionTaggedLiteral(writer, pageVirtualPath, attrVal.Prefix); } // Calculate length of the source span by the position of the next value (or suffix) int sourceLength = next.Position - attrVal.Value.Position; BeginContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); if (attrVal.Literal) { WriteLiteralTo(writer, val.Value); } else { // Patch: Don't use valStr, use val.Value WriteTo(writer, val.Value); // Write value } EndContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal); wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, pageVirtualPath, suffix); } } }
/// <summary> /// Writes a <see cref="PositionTagged{T}" /> literal to the result. /// </summary> /// <param name="writer">The writer.</param> /// <param name="value">The literal to be written.</param> private void WritePositionTaggedLiteral(TextWriter writer, PositionTagged <string> value) { WriteLiteralTo(writer, value.Value); }
protected internal virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values) { bool first = true; bool wroteSomething = false; if (values.Length == 0) { // Explicitly empty attribute, so write the prefix and suffix WritePositionTaggedLiteral(writer, prefix); WritePositionTaggedLiteral(writer, suffix); } else { for (int i = 0; i < values.Length; i++) { AttributeValue attrVal = values[i]; PositionTagged<object> val = attrVal.Value; PositionTagged<string> next = i == values.Length - 1 ? suffix : // End of the list, grab the suffix values[i + 1].Prefix; // Still in the list, grab the next prefix bool? boolVal = null; if (val.Value is bool) { boolVal = (bool)val.Value; } if (val.Value != null && (boolVal == null || boolVal.Value)) { string valStr = val.Value as string; if (valStr == null) { valStr = val.Value.ToString(); } if (boolVal != null) { Debug.Assert(boolVal.Value); valStr = name; } if (first) { WritePositionTaggedLiteral(writer, prefix); first = false; } else { WritePositionTaggedLiteral(writer, attrVal.Prefix); } // Calculate length of the source span by the position of the next value (or suffix) int sourceLength = next.Position - attrVal.Value.Position; if (attrVal.Literal) { WriteLiteralTo(writer, valStr); } else { WriteTo(writer, valStr); // Write value } wroteSomething = true; } } if (wroteSomething) { WritePositionTaggedLiteral(writer, suffix); } } }