public StringLiteralPart(StringLiteralPartType type, string data, int index)
{
Type = type;
Data = data;
Index = index;
Length = data.Length;
}
public StringLiteralPart(StringLiteralPartType type, string data, int index)
{
Type = type;
Data = data;
Index = index;
Length = data.Length;
}
private string GetModelValue(IModelValueProviderFactory factory, IDictionary<string, object> documentHost, object model, StringLiteralPartType type, string data)
{
Type modelType = model != null ? model.GetType() : null;
object value;
switch (type)
{
case StringLiteralPartType.Encoded:
//get the valuetype
if (factory.Get(modelType).GetValue(documentHost, model, data, out value))
{
return System.Net.WebUtility.HtmlEncode(value.ToString());
}
break;
case StringLiteralPartType.Raw:
if (factory.Get(modelType).GetValue(documentHost, model, data, out value))
{
return value.ToString();
}
break;
}
//default type is string literal
return data;
}
private string GetModelValue(IModelValueProviderFactory factory, object model, StringLiteralPartType type, string data)
{
switch (type)
{
case StringLiteralPartType.Encoded:
return System.Net.WebUtility.HtmlEncode((string)factory.Get(model.GetType()).GetValue(model, Parrot.Infrastructure.ValueType.Property, data));
case StringLiteralPartType.Raw:
return (string)factory.Get(model.GetType()).GetValue(model, Parrot.Infrastructure.ValueType.Property, data);
}
//default type is string literal
return data;
}
public void StringLiteralParserTests(string delimiter, StringLiteralPartType encoding)
{
var parts = new StringLiteral(String.Format("\"this {0}is awesome {0}right\"", delimiter)).Values;
Assert.AreEqual(4, parts.Count);
Assert.AreEqual(StringLiteralPartType.Literal, parts[0].Type);
Assert.AreEqual(encoding, parts[1].Type);
Assert.AreEqual(StringLiteralPartType.Literal, parts[2].Type);
Assert.AreEqual(encoding, parts[1].Type);
Assert.AreEqual("this ", parts[0].Data);
Assert.AreEqual("is", parts[1].Data);
Assert.AreEqual(" awesome ", parts[2].Data);
Assert.AreEqual("right", parts[3].Data);
parts = new StringLiteral(String.Format("\"this contains a {0} but not a keyword\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(StringLiteralPartType.Literal, parts[0].Type);
parts = new StringLiteral(String.Format("\"{0}keyword_only\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual("keyword_only", parts[0].Data);
parts = new StringLiteral(String.Format("\"{0}keyword_first followed by more words\"", delimiter)).Values;
Assert.AreEqual(2, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual(StringLiteralPartType.Literal, parts[1].Type);
parts = new StringLiteral(String.Format("\"{0}keyword.with.dot\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual("keyword.with.dot", parts[0].Data);
parts = new StringLiteral(String.Format("\"this is an {0}{0} escaped colon\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(String.Format("this is an {0} escaped colon", delimiter), parts[0].Data);
parts = new StringLiteral(String.Format("\"{0}keyword_only_endsin. a dot\"", delimiter)).Values;
Assert.AreEqual(2, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual(StringLiteralPartType.Literal, parts[1].Type);
Assert.AreEqual("keyword_only_endsin", parts[0].Data);
Assert.AreEqual(". a dot", parts[1].Data);
}
public void StringLiteralParserTests(string delimiter, StringLiteralPartType encoding)
{
var parts = new StringLiteral(new MemoryHost(), string.Format("\"this {0}is awesome {0}right\"", delimiter)).Values;
Assert.AreEqual(4, parts.Count);
Assert.AreEqual(StringLiteralPartType.Literal, parts[0].Type);
Assert.AreEqual(encoding, parts[1].Type);
Assert.AreEqual(StringLiteralPartType.Literal, parts[2].Type);
Assert.AreEqual(encoding, parts[1].Type);
Assert.AreEqual("this ", parts[0].Data);
Assert.AreEqual("is", parts[1].Data);
Assert.AreEqual(" awesome ", parts[2].Data);
Assert.AreEqual("right", parts[3].Data);
parts = new StringLiteral(new MemoryHost(), string.Format("\"this contains a {0} but not a keyword\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(StringLiteralPartType.Literal, parts[0].Type);
parts = new StringLiteral(new MemoryHost(), string.Format("\"{0}keyword_only\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual("keyword_only", parts[0].Data);
parts = new StringLiteral(new MemoryHost(), string.Format("\"{0}keyword_first followed by more words\"", delimiter)).Values;
Assert.AreEqual(2, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual(StringLiteralPartType.Literal, parts[1].Type);
parts = new StringLiteral(new MemoryHost(), string.Format("\"{0}keyword.with.dot\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual("keyword.with.dot", parts[0].Data);
parts = new StringLiteral(new MemoryHost(), string.Format("\"this is an {0}{0} escaped colon\"", delimiter)).Values;
Assert.AreEqual(1, parts.Count);
Assert.AreEqual(string.Format("this is an {0} escaped colon", delimiter), parts[0].Data);
parts = new StringLiteral(new MemoryHost(), string.Format("\"{0}keyword_only_endsin. a dot\"", delimiter)).Values;
Assert.AreEqual(2, parts.Count);
Assert.AreEqual(encoding, parts[0].Type);
Assert.AreEqual(StringLiteralPartType.Literal, parts[1].Type);
Assert.AreEqual("keyword_only_endsin", parts[0].Data);
Assert.AreEqual(". a dot", parts[1].Data);
}
private List <StringLiteralPart> Parse(string source)
{
List <StringLiteralPart> parts = new List <StringLiteralPart>(128);
int tempCounter = 0;
char[] c = new char[source.Length];
for (int i = 0; i < source.Length; i++)
{
if (source[i] == '@' || source[i] == '=')
{
char comparer = source[i];
StringLiteralPartType comparerType = comparer == '@'
? StringLiteralPartType.Encoded
: StringLiteralPartType.Raw;
i += 1;
//look ahead by 1
if (source[Math.Min(source.Length - 1, i)] == comparer)
{
//it's a single "@" escaped
c[tempCounter++] = comparer;
}
else if (IsIdentifierHead(source[i]))
{
//build a new word
if (tempCounter > 0)
{
parts.Add(new StringLiteralPart(StringLiteralPartType.Literal, new string(c, 0, tempCounter), i - tempCounter));
}
tempCounter = 0;
var word = new StringBuilder();
//check for non-identifier character
//read until non-identifier character
for (; i < source.Length; i++, tempCounter++)
{
if (!IsIdTail(source[i]))
{
break;
}
word.Append(source[i]);
}
if (word[word.Length - 1] == '.')
{
word.Length -= 1;
parts.Add(new StringLiteralPart(comparerType, word.ToString(), i - tempCounter));
tempCounter = 0;
c[tempCounter++] = '.';
}
else
{
parts.Add(new StringLiteralPart(comparerType, word.ToString(), i - tempCounter));
tempCounter = 0;
}
if (i < source.Length)
{
c[tempCounter++] = source[i];
}
}
else
{
c[tempCounter++] = comparer;
i -= 1;
}
}
else
{
c[tempCounter++] = source[i];
}
}
if (tempCounter > 0)
{
parts.Add(new StringLiteralPart(StringLiteralPartType.Literal, new string(c, 0, tempCounter), source.Length - tempCounter));
}
return(parts);
}
private string GetModelValue(IModelValueProviderFactory factory, object model, StringLiteralPartType type, string data)
{
switch (type)
{
case StringLiteralPartType.Encoded:
return(System.Net.WebUtility.HtmlEncode((string)factory.Get(model.GetType()).GetValue(model, Parrot.Infrastructure.ValueType.Property, data)));
case StringLiteralPartType.Raw:
return((string)factory.Get(model.GetType()).GetValue(model, Parrot.Infrastructure.ValueType.Property, data));
}
//default type is string literal
return(data);
}
private string GetModelValue(IModelValueProviderFactory factory, IDictionary <string, object> documentHost, object model, StringLiteralPartType type, string data)
{
Type modelType = model != null?model.GetType() : null;
object value;
switch (type)
{
case StringLiteralPartType.Encoded:
//get the valuetype
if (factory.Get(modelType).GetValue(documentHost, model, data, out value))
{
return(System.Net.WebUtility.HtmlEncode(value.ToString()));
}
break;
case StringLiteralPartType.Raw:
if (factory.Get(modelType).GetValue(documentHost, model, data, out value))
{
return(value.ToString());
}
break;
}
//default type is string literal
return(data);
}
