public Tokenizer(TokenizerOptions options)
{
parser = new TokenParser(options);
Options = options;
log = LogProvider.For <Tokenizer>();
}
public bool TryAssign(object target, StringBuilder value, TokenizerOptions options, FileLocation location, out Token assigned, out object assignedValue)
{
assigned = null;
assignedValue = null;
var valueString = value.ToString();
foreach (var token in tokens)
{
if (token.Assign(target, valueString, options, location, out assignedValue))
{
assigned = token;
return(true);
}
}
return(false);
}
public TokenMatcher(TokenizerOptions options) : this()
{
tokenizer.Options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="Tokenizer"/> class.
/// </summary>
public Tokenizer()
{
Options = TokenizerOptions.Defaults;
OperatorFactory = new TokenOperatorFactory();
}
internal bool Assign(object target, string value, TokenizerOptions options, FileLocation location, out object assignedValue)
{
assignedValue = null;
if (string.IsNullOrEmpty(value) && IsFrontMatterToken == false)
{
return(false);
}
if (IsNull)
{
return(false);
}
if (string.IsNullOrWhiteSpace(Name))
{
return(false);
}
value = value.TrimTrailingNewLine();
if (string.IsNullOrEmpty(value) == false && TerminateOnNewLine)
{
var index = value.IndexOf("\n");
if (index > 0)
{
value = value.Substring(0, index);
}
}
Log.Verbose("-> Ln: {0} Col: {1} : Assigning {2}[{3}] as {4}", location.Line, location.Column, Name, Id, value.ToLogInfoString());
if (options.TrimTrailingWhiteSpace)
{
value = value.TrimEnd();
}
assignedValue = value;
using (new LogIndentation())
{
foreach (var decorator in Decorators)
{
if (decorator.IsTransformer)
{
var transformed = decorator.CanTransform(assignedValue, out var output);
if (transformed == false)
{
Log.Verbose($"-> {decorator.DecoratorType.Name}: Unable to transform value '{assignedValue}'!");
return(false);
}
if (decorator.DecoratorType == typeof(SetTransformer))
{
Log.Verbose($"-> {decorator.DecoratorType.Name}: Set value to '{output}'");
}
else if (output is DateTime time)
{
Log.Verbose($"-> {decorator.DecoratorType.Name}: Transformed '{assignedValue}' to {time:yyyy-MM-dd HH:mm:ss} ({time.Kind})");
}
else if (output is IEnumerable <string> list)
{
Log.Verbose($"-> {decorator.DecoratorType.Name}: Split '{assignedValue}' into [] {{ {string.Join(", ", list)} }}");
}
else
{
Log.Verbose($"-> {decorator.DecoratorType.Name}: Transformed '{assignedValue}' to '{output}' ({output.GetType().Name})");
}
assignedValue = output;
}
if (decorator.IsValidator)
{
if (decorator.Validate(assignedValue))
{
Log.Verbose($"-> {decorator.DecoratorType.Name} OK!");
}
else
{
Log.Verbose($"-> {decorator.DecoratorType.Name} Validation Failure: {value}");
return(false);
}
}
}
}
if (target is IDictionary <string, object> dictionary)
{
return(SetDictionaryValue(dictionary, assignedValue));
}
// Target can be null if not reflecting onto an object
if (target is null)
{
return(true);
}
try
{
if (Concatenate)
{
if (assignedValue == null)
{
return(true);
}
var current = target.GetValue(Name);
if (CanConcatenate(current, assignedValue))
{
target.SetValue(Name, ConcatenateValues(current, assignedValue, ConcatenationString));
}
else
{
throw new TokenAssignmentException(this, $"Unable to concatenate type {assignedValue.GetType().Name} to {Name}");
}
}
else
{
target.SetValue(Name, assignedValue);
}
}
catch (MissingMemberException)
{
Log.Verbose($"Missing property on target: {Name}");
if (options.IgnoreMissingProperties == false)
{
throw;
}
}
catch (TypeConversionException ex)
{
Log.Verbose($"{ex.Message}");
return(false);
}
catch (Exception e)
{
var ex = new TokenAssignmentException(this, e);
throw ex;
}
return(true);
}
internal bool Assign(object target, string value, TokenizerOptions options, ILog log)
{
if (CanAssign(value, log) == false)
{
return(false);
}
if (TerminateOnNewLine)
{
var index = value.IndexOf("\n");
if (index > 0)
{
value = value.Substring(0, index);
}
}
if (options.TrimTrailingWhiteSpace)
{
value = value.TrimEnd();
}
object transformed = value;
foreach (var transformer in Transformers)
{
transformed = transformer.Transform(transformed);
}
if (target is List <Substitution> list)
{
list.Add(new Substitution
{
Name = Name,
Value = transformed
});
return(true);
}
log?.Debug($"Assigning '{Name}' to '{transformed}'");
try
{
target.SetValue(Name, transformed);
}
catch (MissingMemberException ex)
{
if (options.ThrowExceptionOnMissingProperty)
{
log?.Error(ex, $"Missing property on target: {Name}");
throw;
}
log?.Warn($"Missing property on target: {Name}");
}
catch (Exception e)
{
log?.Error(e, $"Unexpected error when assigning '{Name}' to '{transformed}':");
var ex = new TokenAssignmentException(this, e);
throw ex;
}
return(true);
}
internal bool Assign(object target, string value, TokenizerOptions options)
{
return(Assign(target, value, options, null));
}
