private void ParseReplacement(TokenReader <DocumentToken> reader, List <IDocumentExpression> ret)
{
var openToken = AdvanceAndExpectConstantType(reader, DocumentTokenType.BeginReplacementSegment);
var replacementKeyToken = AdvanceAndExpect(reader, DocumentTokenType.ReplacementKey, "replacement key", skipWhitespace: true);
List <DocumentToken> parameters = new List <DocumentToken>();
List <DocumentToken> body = new List <DocumentToken>();
while (reader.CanAdvance(skipWhitespace: true) && reader.Peek(skipWhitespace: true).TokenType == DocumentTokenType.ReplacementParameter)
{
var paramToken = reader.Advance(skipWhitespace: true);
parameters.Add(paramToken);
}
DocumentToken closeReplacementToken;
if (reader.TryAdvance(out closeReplacementToken, skipWhitespace: true) == false)
{
throw Unexpected(string.Format("'{0}' or '{1}'", DocumentToken.GetTokenTypeValue(DocumentTokenType.EndReplacementSegment), DocumentToken.GetTokenTypeValue(DocumentTokenType.QuickTerminateReplacementSegment)));
}
if (closeReplacementToken.TokenType == DocumentTokenType.EndReplacementSegment)
{
body.AddRange(ReadReplacementBody(reader, replacementKeyToken));
}
else if (closeReplacementToken.TokenType == DocumentTokenType.QuickTerminateReplacementSegment)
{
// do nothing, there is no body when the quick termination replacement segment is used
}
else
{
throw Unexpected(string.Format("'{0}' or '{1}'", DocumentToken.GetTokenTypeValue(DocumentTokenType.EndReplacementSegment), DocumentToken.GetTokenTypeValue(DocumentTokenType.QuickTerminateReplacementSegment)), closeReplacementToken);
}
IDocumentExpressionProvider provider;
if (this.expressionProviders.TryGetValue(replacementKeyToken.Value, out provider) == false)
{
provider = new EvalExpressionProvider();
}
var context = new DocumentExpressionContext
{
OpenToken = openToken,
CloseToken = closeReplacementToken,
Parameters = parameters.AsReadOnly(),
Body = body.AsReadOnly(),
ReplacementKeyToken = replacementKeyToken,
};
var expression = provider.CreateExpression(context);
ret.Add(expression);
}
/// <summary>
/// Creates a table expression from the given document info.
/// </summary>
/// <param name="context">The context that contains information about the document being rendered</param>
/// <returns>The created document expression</returns>
public IDocumentExpression CreateExpression(DocumentExpressionContext context)
{
if (context.Body.Count > 0)
{
throw new DocumentRenderException("table tags can't have a body", context.ReplacementKeyToken);
}
TokenReader <DocumentToken> reader = new TokenReader <DocumentToken>(context.Parameters);
DocumentToken variableExpressionToken;
if (reader.TryAdvance(out variableExpressionToken, skipWhitespace: true) == false)
{
throw new DocumentRenderException("missing collection expression after table tag", context.ReplacementKeyToken);
}
List <DocumentToken> columns = new List <DocumentToken>();
bool showDefaults = true;
bool showPossibilities = true;
while (reader.CanAdvance(skipWhitespace: true))
{
var nextToken = reader.Advance(skipWhitespace: true);
if (nextToken.Value == "-HideDefaults")
{
showDefaults = false;
}
else if (nextToken.Value == "-HideEnumValues")
{
showPossibilities = false;
}
else
{
columns.Add(nextToken);
}
}
if (columns.Count == 0)
{
throw new DocumentRenderException("table elements need to have at least one column parameter", context.ReplacementKeyToken);
}
return(new TableExpression(variableExpressionToken, columns, context)
{
ShowDefaultValuesForArguments = showDefaults, ShowPossibleValuesForArguments = showPossibilities
});
}
/// <summary>
/// Creates either an if or an ifnot expression, based on its configuration, using the given document info.
/// </summary>
/// <param name="replacementKeyToken">The replacement key token whose value is either 'if' or 'ifnot'</param>
/// <param name="parameters">There should be no parameters to an if or ifnot expression</param>
/// <param name="body">The body which will be conditionally rendered.</param>
/// <returns>The expression, either an if or an ifnot expression</returns>
public IDocumentExpression CreateExpression(DocumentToken replacementKeyToken, List <DocumentToken> parameters, List <DocumentToken> body)
{
TokenReader <DocumentToken> reader = new TokenReader <DocumentToken>(parameters);
DocumentToken ifExpressionToken;
if (reader.TryAdvance(out ifExpressionToken, skipWhitespace: true) == false)
{
throw new DocumentRenderException("missing if expression", replacementKeyToken);
}
if (reader.CanAdvance(skipWhitespace: true))
{
throw new DocumentRenderException("unexpected parameters after if expression", reader.Advance(skipWhitespace: true));
}
return(not ? new IfNotExpression(ifExpressionToken, body) : new IfExpression(ifExpressionToken, body));
}
private List <DocumentToken> ReadReplacementBody(TokenReader <DocumentToken> reader, DocumentToken replacementKeyToken)
{
List <DocumentToken> replacementContents = new List <DocumentToken>();
int numOpenReplacements = 1;
while (reader.CanAdvance())
{
if (reader.Peek().TokenType == DocumentTokenType.BeginReplacementSegment)
{
numOpenReplacements++;
}
else if (reader.Peek().TokenType == DocumentTokenType.QuickTerminateReplacementSegment)
{
numOpenReplacements--;
if (numOpenReplacements == 0)
{
throw Unexpected(reader.Peek());
}
}
else if (reader.Peek().TokenType == DocumentTokenType.BeginTerminateReplacementSegment)
{
numOpenReplacements--;
if (numOpenReplacements == 0)
{
AdvanceAndExpectConstantType(reader, DocumentTokenType.BeginTerminateReplacementSegment);
AdvanceAndExpect(reader, DocumentTokenType.ReplacementKey, replacementKeyToken.Value, skipWhitespace: true);
AdvanceAndExpectConstantType(reader, DocumentTokenType.EndReplacementSegment);
break;
}
}
replacementContents.Add(reader.Advance());
}
if (numOpenReplacements != 0)
{
throw Unexpected("end of '" + replacementKeyToken.Value + "' replacement");
}
return(replacementContents);
}
/// <summary>
/// Parses the given tokens into document expressions that can then be evaluated against a data context.
/// </summary>
/// <param name="tokens">The tokens to parse</param>
/// <returns>a list of document expressions</returns>
public List <IDocumentExpression> Parse(IEnumerable <DocumentToken> tokens)
{
List <IDocumentExpression> ret = new List <IDocumentExpression>();
TokenReader <DocumentToken> reader = new TokenReader <DocumentToken>(tokens);
while (reader.CanAdvance())
{
if (reader.Peek().TokenType == DocumentTokenType.BeginReplacementSegment)
{
ParseReplacement(reader, ret);
}
else
{
var plain = new PlainTextDocumentExpression(reader.Advance());
ret.Add(plain);
}
}
return(ret);
}
/// <summary>
/// Parses an object path expression from a string.
/// </summary>
/// <param name="expression">The expression text to parse</param>
/// <returns>The parsed expression</returns>
public static ObjectPathExpression Parse(string expression)
{
if (expression == null)
{
throw new ArgumentNullException("path cannot be null");
}
if (expression.Length == 0)
{
throw new FormatException("Cannot parse empty string");
}
Tokenizer <ObjectPathToken> tokenizer = new Tokenizer <ObjectPathToken>();
tokenizer.TokenFactory = ObjectPathToken.TokenFactoryImpl;
tokenizer.WhitespaceBehavior = WhitespaceBehavior.DelimitAndInclude;
tokenizer.DoubleQuoteBehavior = DoubleQuoteBehavior.IncludeQuotedTokensAsStringLiterals;
tokenizer.Delimiters.Add("[");
tokenizer.Delimiters.Add("]");
tokenizer.Delimiters.Add(".");
List <ObjectPathToken> tokens = tokenizer.Tokenize(expression);
TokenReader <ObjectPathToken> reader = new TokenReader <ObjectPathToken>(tokens);
List <IObjectPathElement> pathElements = new List <IObjectPathElement>();
bool lastTokenWasNavigation = false;
while (reader.CanAdvance(skipWhitespace: true))
{
var currentToken = reader.Advance(skipWhitespace: true);
if (lastTokenWasNavigation == true && currentToken.TokenType == ObjectPathTokenType.IndexerOpen)
{
throw new FormatException("Expected property, got '['" + " at " + currentToken.Position);
}
lastTokenWasNavigation = false;
if (pathElements.Count == 0 && currentToken.TokenType == ObjectPathTokenType.NavigationElement)
{
throw new FormatException("Expected property or index, got '" + currentToken.Value + "'" + " at " + currentToken.Position);
}
if (currentToken.TokenType == ObjectPathTokenType.IndexerClose ||
currentToken.TokenType == ObjectPathTokenType.StringLiteral)
{
throw new FormatException("Expected property or index, got '" + currentToken.Value + "'" + " at " + currentToken.Position);
}
if (currentToken.TokenType == ObjectPathTokenType.IndexerOpen)
{
// read index value
if (reader.TryAdvance(out currentToken, skipWhitespace: true) == false)
{
throw new FormatException("Expected index value, got end of string");
}
if (currentToken.TokenType == ObjectPathTokenType.Identifier || currentToken.TokenType == ObjectPathTokenType.StringLiteral)
{
string indexValueText = currentToken.Value;
if (currentToken.TokenType == ObjectPathTokenType.StringLiteral)
{
indexValueText = indexValueText.Substring(1, indexValueText.Length - 2);
}
object indexValue;
int indexValueInt;
if (int.TryParse(indexValueText, out indexValueInt) == false)
{
indexValue = indexValueText;
}
else
{
indexValue = indexValueInt;
}
// read index close
if (reader.TryAdvance(out currentToken, skipWhitespace: true) == false)
{
throw new FormatException("Expected ']', got end of string");
}
if (currentToken.TokenType != ObjectPathTokenType.IndexerClose)
{
throw new FormatException("Expected ']', got '" + currentToken.Value + "' at " + currentToken.Position);
}
IndexerPathElement el = new IndexerPathElement(indexValue);
pathElements.Add(el);
if (reader.TryAdvance(out currentToken, skipWhitespace: true))
{
if (currentToken.TokenType != ObjectPathTokenType.NavigationElement)
{
throw new FormatException("Expected '.', got '" + currentToken.Value + "' at " + currentToken.Position);
}
if (reader.CanAdvance(skipWhitespace: true) == false)
{
throw new FormatException("Expected property, got end of string");
}
lastTokenWasNavigation = true;
}
}
else
{
throw new ArgumentException("Unexpected token '" + currentToken.Value + "' at " + currentToken.Position);
}
}
else if (currentToken.TokenType == ObjectPathTokenType.Identifier)
{
PropertyPathElement el = new PropertyPathElement(currentToken.Value);
pathElements.Add(el);
}
else if (currentToken.TokenType == ObjectPathTokenType.NavigationElement)
{
// do nothing
}
else
{
throw new ArgumentException("Unexpected token '" + currentToken.Value + "' at " + currentToken.Position);
}
}
return(new ObjectPathExpression(pathElements));
}