public static void GrammarCheckDirectory(this TemplatorParser parser, string path, string[] filters, int depth)
{
var files = filters.IsNullOrEmptyValue()
? Directory.EnumerateFiles(path)
: Directory.EnumerateFiles(path).Where(f => filters.Any(fi => f.EndsWith(fi, StringComparison.OrdinalIgnoreCase)));
foreach (var name in files)
{
using (var sr = new StreamReader(name))
{
parser.StartOver();
parser.GrammarCheck(sr.ReadToEnd(), name, name.ToLower().EndsWith(".xml"));
}
if (parser.ReachedMaxError)
{
return;
}
}
if (depth-- > 0)
{
foreach (var d in Directory.EnumerateDirectories(path))
{
parser.GrammarCheckDirectory(d, filters, depth);
if (parser.ReachedMaxError)
{
return;
}
}
}
}
public static string LoadCsvTemplate(this TemplatorParser parser, Stream stream, IDictionary <string, object> input, IDictionary <string, TextHolder> preparsedHolders = null, string mergeHoldersInto = null)
{
using (var rd = new StreamReader(stream))
{
return(parser.ParseCsv(rd.ReadToEnd(), input, preparsedHolders, mergeHoldersInto));
}
}
public static Pair <string, string> Get2Params(TemplatorParser parser, TextHolder holder, string keyword, string delimitor)
{
var p = new SeekableString((string)holder[keyword]);
var p1 = p.ReadTo(true, parser.Config.EscapePrefix, delimitor);
var p2 = p.Left;
return(new Pair <string, string>(p1, p2));
}
public static void SetParentInputIndex(TemplatorParser parser, TextHolder holder, int?index)
{
if (parser.ParentContext == null)
{
return;
}
var key = (parser.StackLevel - 1) + holder.Name + "InputIndex";
parser.ParentContext[key] = index;
}
public static int?GetParentInputIndex(TemplatorParser parser, TextHolder holder)
{
if (parser.ParentContext == null)
{
return(null);
}
var key = (parser.StackLevel - 1) + holder.Name + "InputIndex";
return((int?)parser.ParentContext[key]);
}
public static void SetParentInputCount(TemplatorParser parser, TextHolder holder, int?count)
{
if (parser.ParentContext == null)
{
return;
}
var key = (parser.StackLevel - 1) + holder.Name + "InputCount";
parser.ParentContext[key] = count;
}
public static object GetValue(TemplatorParser parser, string holderName, IDictionary <string, object> input, object defaultRet, int inherited = 0)
{
var holder = GetHolder(input, holderName, parser.Config);
if (inherited > 0)
{
holder[parser.Config.KeywordSeekup] = inherited;
holder.Keywords.Add(parser.Config.Keywords[parser.Config.KeywordSeekup].Create());
}
return(GetValue(parser, holder, input, defaultRet));
}
private static void NestHolder(TemplatorParser parser)
{
if (!parser.Config.AllowNested)
{
parser.LogSyntaxError(parser.Config.SyntaxErrorNestedHolders);
}
parser.OnGrammerTokenCreated(parser.Config.Begin, parser.Config.TermBeginEnd);
parser.PushContext(parser.Context.Input, null, parser.Context.Holder);
parser.Context.State.Begin = true;
parser.Context.Holder = new TextHolder();
}
public static object GetInputValue(TemplatorParser parser, string key, IDictionary <string, object> input, object defaultRet = null, int seekup = 0)
{
var i = input;
var v = i.GetOrDefault(key, defaultRet);
while (v == null && seekup-- > 0 && i.ContainsKey(parser.Config.ReservedKeywordParent))
{
i = (IDictionary <string, object>)i[parser.Config.ReservedKeywordParent];
v = GetInputValue(parser, key, i, defaultRet);
}
return(v);
}
private static object KeywordPostParse(TemplatorParser parser, TextHolder holder, object current, TemplatorKeyword key)
{
if (current.IsNullOrEmptyValue() && !key.HandleNullOrEmpty)
{
return(current);
}
var ret = key.OnGetValue(holder, parser, current);
if (((key.ManipulateInput && parser.Config.SaveManipulatedResults) ||
(key.CalculateInput && parser.Config.CacheCalculatedResults)) && !key.IndicatesOptional)
{
parser.CacheValue(holder.Name, ret, true);
}
return(ret);
}
public static bool EvalulateCondition(TemplatorParser parser, IDictionary <string, object> input, TextHolder holder, string condition, object eav)
{
var not = false;
if (condition != null && condition.StartsWith("!"))
{
not = true;
condition = condition.Substring(1, condition.Length - 1);
}
if (!condition.IsNullOrEmptyValue())
{
eav = GetInputValue(parser, condition, input);
eav = eav ?? parser.RequireValue(parser, GetHolder(input, condition, parser.Config));
}
var hasValue = eav == null || (parser.Config.EmptyAsNulls && eav.IsNullOrEmptyValue());
return(not == hasValue);
}
public static object Aggregate(this TemplatorParser parser, object current, TextHolder holder, string aggregateField, IDictionary <string, object> input, Func <object, object, object> aggregateFunc)
{
foreach (var c in aggregateField.Split(Constants.SemiDelimChar))
{
string left;
var fieldName = c.GetUntil(".", out left);
if (!left.IsNullOrWhiteSpace())
{
var list = GetChildCollection(input, fieldName, parser.Config);
current = list.EmptyIfNull().Aggregate(current, (current1, subInput) => parser.Aggregate(current1, holder, left, subInput, aggregateFunc));
}
else
{
var value = GetUnformmatedValue(parser, fieldName, input);
current = aggregateFunc(current, value);
}
}
return(current);
}
public static object GetValue(TemplatorParser parser, TextHolder holder, IDictionary <string, object> input, object defaultRet)
{
object value = null;
if (input != null && input.ContainsKey(holder.Name))
{
value = input[holder.Name];
}
if (value == null)
{
value = holder.Keywords.EmptyIfNull().Where(k => k.CalculateInput && k.OnGetValue != null)
.Aggregate((object)null, (current, k) => KeywordPostParse(parser, holder, current, k));
}
value = value ?? parser.RequireValue(parser, holder, defaultRet, input);
value = holder.Keywords.EmptyIfNull().Where(key => !key.CalculateInput && key.OnGetValue != null)
.Aggregate(value, (current, k) => KeywordPostParse(parser, holder, current, k));
if (parser.Context.ChildResultBefore.Length > 0 || parser.Context.ChildResultAfter.Length > 0)
{
value = String.Concat(parser.Context.ChildResultBefore, value, parser.Context.ChildResultAfter);
}
var logger = parser.Context.ChildLogger as TemplatorLogger;
if (logger != null)
{
foreach (var en in logger.Errors)
{
parser.Context.Logger?.LogError(en.FileName, en.Line, en.Column, en.EndLineNumber, en.EndColumnNumber, en.Message);
}
}
if (null == value)
{
if (defaultRet != null)
{
value = defaultRet;
}
else
{
parser.LogError("'{0}' is required", holder.Name);
}
}
return(value);
}
private static void ParseKeywordParam(TemplatorParser parser, string str)
{
if (parser.ParsingKeyword != null)
{
if (parser.ParsingKeyword.Parse != null)
{
parser.ParsingKeyword.Parse(parser, str);
}
else
{
if (!str.IsNullOrEmptyValue())
{
if (!parser.Config.IgnoreUnknownParam)
{
parser.Context.State.Error = true;
throw new TemplatorParamsException();
}
}
parser.Context.Holder[parser.ParsingKeyword.Name] = str.EmptyIfNull();
}
}
}
public static object GetUnformmatedValue(TemplatorParser parser, string fieldName, IDictionary <string, object> input, int seekUp = 0, bool requireInput = true)
{
var value = GetInputValue(parser, fieldName, input, null, seekUp);
var subHolder = GetHolder(input, fieldName, parser.Config, false);
if (value == null)
{
if (subHolder != null)
{
value = subHolder.Keywords.EmptyIfNull().Where(k => k.CalculateInput && k.OnGetValue != null)
.Aggregate((object)null, (current, k) => KeywordPostParse(parser, subHolder, current, k));
}
if (requireInput)
{
value = value ?? parser.RequireValue(parser, subHolder ?? new TextHolder(fieldName), null, input);
}
}
if (subHolder != null)
{
value = subHolder.Keywords.EmptyIfNull().Where(k => k.ManipulateInput && k.OnGetValue != null)
.Aggregate(value, (current, k) => KeywordPostParse(parser, subHolder, current, k));
}
return(value);
}
public static bool EvalulateCondition(TemplatorParser parser, TextHolder holder, string condition, object eav)
{
return(EvalulateCondition(parser, parser.Context.Input, holder, condition, eav));
}
public static XElement LoadXmlTemplate(this TemplatorParser parser, Stream stream, IDictionary <string, object> input, IDictionary <string, TextHolder> preparsedHolders = null, string mergeHoldersInto = null, XmlSchemaSet schemaSet = null)
{
var doc = XDocument.Load(stream);
return(parser.ParseXml(doc, input, preparsedHolders, mergeHoldersInto, schemaSet));
}
public static int?GetInputIndex(TemplatorParser parser, TextHolder holder)
{
var key = parser.StackLevel + holder.Name + "InputIndex";
return((int?)parser.Context[key]);
}
public static void SetInputIndex(TemplatorParser parser, TextHolder holder, int?index)
{
var key = parser.StackLevel + holder.Name + "InputIndex";
parser.Context[key] = index;
}
public static bool InXmlManipulation(this TemplatorParser parser)
{
return(parser.XmlContext?.Attribute != null && parser.XmlContext.Attribute.Name == parser.Config.XmlTemplatorAttributeName);
}
public static void SetInputCount(TemplatorParser parser, TextHolder holder, int?count)
{
var key = parser.StackLevel + holder.Name + "InputCount";
parser.Context[key] = count;
}
