/// <summary>
/// Loads a transform definition from file.
/// </summary>
/// <param name="path">The path to load from.</param>
/// <param name="options">The syntax highlight options.</param>
/// <returns>The loaded transform definition.</returns>
public static TransformDefinition Load(string path, Options options)
{
JObject source = JObject.Parse(File.ReadAllText(path));
JObject patterns = source[PatternsKey] as JObject;
JArray transforms = source[TransformsKey] as JArray;
TransformDefinition definition = new TransformDefinition(options);
RegexOptions patternOptions =
RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled;
foreach (JProperty pattern in patterns.Properties())
{
if (pattern.Value is JObject)
{
JObject patternNode = pattern.Value as JObject;
bool explicitCapture = patternNode[ExplicitKey] != null ?
patternNode[ExplicitKey].Value <bool>() : false;
definition.Patterns[pattern.Name] = new Regex(
patternNode[PatternKey].ToString(),
explicitCapture ? patternOptions | RegexOptions.ExplicitCapture : patternOptions);
}
else
{
definition.Patterns[pattern.Name] = new Regex(
pattern.Value.ToString(), patternOptions);
}
}
foreach (JObject transform in transforms.Children())
{
definition.transforms.Add(
TransformFactory.Load(definition, transform, options));
}
return(definition);
}
/// <summary>
/// Loads a transform from JSON node.
/// </summary>
/// <param name="definition">The transform definition containing the loaded patterns.</param>
/// <param name="node">The serialized JSON node to load from.</param>
/// <param name="options">The code highlight options.</param>
/// <returns>The loaded transform.</returns>
public static ITransform Load(TransformDefinition definition, JObject node, Options options)
{
string transformType = node.Property(TransformTypeKey) != null?
node.Property(TransformTypeKey).Value.ToString() : null;
string className = node.Property(TokenClassKey)
.Value.ToString();
Regex pattern = definition.Patterns[node.Property(TokenPatternKey)
.Value.ToString()];
string[] excludeClassNames = node[ExcludeClassesKey] != null ?
node[ExcludeClassesKey].ToObject <string[]>() : new string[0];
string name = null;
string description = null;
string patternName = null;
string modifierPatternName = null;
Regex modifierPattern = null;
if (node[ModifierPatternKey] != null)
{
modifierPatternName = node[ModifierPatternKey].ToString();
modifierPattern = definition.Patterns[modifierPatternName];
}
if (options.DebugInfo)
{
if (node.Property(NameKey) != null)
{
name = node.Property(NameKey).Value.ToString();
}
if (node.Property(DescriptionKey) != null)
{
description = node.Property(DescriptionKey).Value.ToString();
}
patternName = node.Property(TokenPatternKey).Value.ToString();
}
switch (transformType)
{
default:
case TokenType:
{
return(new TransformToken(
name,
description,
patternName,
pattern,
options.DebugInfo ? modifierPatternName : null,
modifierPattern,
className,
excludeClassNames));
}
case TokenSpanType:
{
JArray transformNodes = node[TransformsKey] as JArray;
List <TransformToken> transforms = new List <TransformToken>();
if (transformNodes != null && transformNodes.Count > 0)
{
foreach (JObject transformNode in transformNodes)
{
transforms.Add(
TransformFactory.Load(definition, transformNode, options) as TransformToken);
}
}
// Escape by default.
bool escape = node.Property(EscapeKey) != null?
bool.Parse(node.Property(EscapeKey).Value.ToString()) : true;
return(new TransformTokenSpan(
name,
description,
patternName,
pattern,
modifierPatternName,
modifierPattern,
className,
transforms,
escape,
excludeClassNames));
}
}
}
