public override bool Evaluate(TSource source)
{
foreach (IEvaluate <TSource> expr in Expressions)
{
if (!JavaScriptHelpers.IsTruthy(expr.Evaluate(source)))
{
return(false);
}
}
return(true);
}
public override bool Evaluate(TSource source)
{
return(JavaScriptHelpers.IsTruthy(Token.GetValue(source)));
}
public override bool Evaluate(TSource source)
{
return(JavaScriptHelpers.IsTruthy(Inner.Evaluate(source)));
}
internal static LogicalExpression <TSource> CompileLogicalExpression <TSource, TToken>(string text, Func <string, TToken> pathToken)
where TToken : Token <TSource>
{
LogicalExpression <TSource> result = null;
var whereMatch = parser.Match(text);
if (whereMatch == null || !whereMatch.Success)
{
throw new ArgumentException("Invalid expression \"" + text + "\".");
}
var exprCaptures = whereMatch.Groups["expr"].Captures;
var nextCaptures = whereMatch.Groups["next"].Captures;
AndExpressionGroup <TSource> andGroup = null;
for (var i = 0; i < exprCaptures.Count; i++)
{
var exprText = exprCaptures[i].Value.Trim();
var nextText = nextCaptures[i].Value.Trim();
IEvaluate <TSource> expr;
if (Regex.IsMatch(exprText, @"^\(.*\)$"))
{
expr = CompileLogicalExpression <TSource, TToken>(exprText.Substring(1, exprText.Length - 2), pathToken);
}
else
{
var exprMatch = exprParser.Match(exprText);
if (exprMatch == null || !exprMatch.Success)
{
throw new Exception("Invalid expression \"" + exprText + "\".");
}
var leftText = exprMatch.Groups["left"].Value.Trim();
var opText = exprMatch.Groups["op"].Value.Trim();
var rightText = exprMatch.Groups["right"].Value.Trim();
if (string.IsNullOrEmpty(opText))
{
// No operator, so this is a truthy property or constant check.
object value;
if (JavaScriptHelpers.TryParseConstant(leftText, out value))
{
expr = new TruthyConstantExpression <TSource>(new ConstantToken <TSource>(value));
}
else
{
expr = new PathExpression <TSource>(pathToken(leftText));
}
}
else
{
// Parse the comparison operator.
LogicalOperator op = ParseLogicalOperator(opText);
// Parse the left-hand token.
Token <TSource> leftToken;
object leftValue;
if (JavaScriptHelpers.TryParseConstant(leftText, out leftValue))
{
leftToken = new ConstantToken <TSource>(leftValue);
}
else
{
leftToken = pathToken(leftText);
}
// Parse the right-hand token.
Token <TSource> rightToken;
object rightValue;
if (JavaScriptHelpers.TryParseConstant(rightText, out rightValue))
{
rightToken = new ConstantToken <TSource>(rightValue);
}
else
{
rightToken = pathToken(rightText);
}
// Create the expression from "left op right".
expr = new CompareExpression <TSource>(leftToken, op, rightToken);
}
}
if (nextText == "&&" && andGroup == null)
{
// There is currently no active and group and the next expression
// will be "ANDed", so start a new and group, beginning with this expression.
andGroup = AndExpressionGroup <TSource> .Begin(expr);
}
else if (andGroup != null)
{
// There is an active and group expression, so add this expression to it.
andGroup.And(expr);
}
else if (result != null)
{
// There is currently a result, so or it with this expression.
result = result.Or(expr);
}
else
{
// There is currently no result, so use this expression as the result.
result = new TruthyExpressionWrapper <TSource>(expr);
}
// Add the existing group if we have reached the end of the expression, or the next expression will be "ORed".
if ((string.IsNullOrEmpty(nextText) || nextText == "||") && andGroup != null)
{
if (result == null)
{
result = andGroup;
}
else
{
result = result.Or(andGroup);
}
andGroup = null;
}
}
return(result);
}