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);
}
}
}
