public PatternResult Evaluate(Schema schema, XPathNavigator navigator, IEnumerable <Let> lets, bool evalAbstract = false)
{
if (this.Abstract && !evalAbstract)
{
return(PatternResult.Empty);
}
List <Let> combined = new List <Let>(lets);
if (this.Lets != null)
{
combined.AddRange(this.Lets);
}
if (this.Parameters != null)
{
combined.AddRange(this.Parameters);
}
var context = new Xslt.SchematronContext(new NameTable(), combined);
var results = new List <RuleResult>();
if (IsA != null)
{
if (schema.AllPatterns.ContainsKey(this.IsA))
{
var pattern = schema.AllPatterns[this.IsA];
var result = pattern.Evaluate(schema, navigator, combined, true);
results.AddRange(result.RuleResults);
}
}
if (this.Rules != null)
{
foreach (var rule in this.Rules)
{
if (!rule.Abstract)
{
var result = rule.Evaluate(schema, navigator, combined);
results.Add(result);
}
}
}
return(new PatternResult()
{
Pattern = this,
PatternFired = results.Any(x => x.RuleFired),
RuleResults = results.ToArray(),
});
}
public RuleResult Evaluate(Schema schema, XPathNavigator navigator, IEnumerable <Let> lets, bool evalAbstract = false)
{
if (this.Abstract && !evalAbstract)
{
return(RuleResult.Empty);
}
List <Let> combined = new List <Let>(lets);
if (this.Lets != null)
{
combined.AddRange(this.Lets);
}
var context = new Xslt.SchematronContext(new NameTable(), combined);
if (schema.Namespaces != null)
{
foreach (var ns in schema.Namespaces)
{
context.AddNamespace(ns.Prefix, ns.Uri);
}
}
var results = new List <EvaluationResult>();
if (compiledContext == null)
{
compiledContext = XPathExpression.Compile(this.Context);
}
compiledContext.SetContext(context);
var executionContext = compiledContext;
if (compiledContext.ReturnType != XPathResultType.NodeSet)
{
var newContext = (string)navigator.Evaluate(compiledContext);
executionContext = XPathExpression.Compile("//" + newContext);
executionContext.SetContext(context);
}
else if (!this.Context.StartsWith("/"))
{
compiledContext = XPathExpression.Compile("//" + this.Context);
compiledContext.SetContext(context);
executionContext = compiledContext;
}
navigator.MoveToRoot();
navigator.MoveToFirstChild();
XPathNodeIterator nodes = navigator.Select(executionContext);
foreach (XPathNavigator nav in nodes)
{
int contextLine = -1;
int contextPosition = -1;
if (nav is IXmlLineInfo info)
{
contextLine = info.LineNumber;
contextPosition = info.LinePosition;
}
string contextName = nav.Name;
if (this.Extensions != null)
{
foreach (var extension in this.Extensions)
{
if (schema.AllRules.ContainsKey(extension.Rule))
{
var rule = schema.AllRules[extension.Rule];
var result = rule.EvaluateAssertions(schema, nav, context);
results.AddRange(result);
}
}
}
var assertResults = this.EvaluateAssertions(schema, nav, context);
foreach (var result in assertResults)
{
result.ContextLine = contextLine;
result.ContextPosition = contextPosition;
result.ContextElement = contextName;
}
results.AddRange(assertResults);
}
return(new RuleResult()
{
Rule = this,
RuleFired = nodes.Count > 0,
ExecutedAssertions = results.ToArray(),
});
}
private EvaluationResult[] EvaluateAssertions(Schema schema, XPathNavigator navigator, Xslt.SchematronContext context)
{
List <EvaluationResult> results = new List <EvaluationResult>();
if (this.Assertions != null)
{
foreach (var assert in this.Assertions)
{
var result = assert.Evaluate(schema, navigator, context);
results.Add(result);
}
}
if (this.Reports != null)
{
foreach (var report in this.Reports)
{
var result = report.Evaluate(schema, navigator, context);
results.Add(result);
}
}
return(results.ToArray());
}
