/// <summary> /// Loads a transform definition if not already loaded. /// </summary> /// <param name="basePath">The base path.</param> /// <param name="name">The transform definition name.</param> /// <param name="options">The syntax highlight options.</param> /// <returns>The loaded transform definition.</returns> public static TransformDefinition Load(string basePath, string name, Options options) { if (!definitions.ContainsKey(name)) { definitions[name] = TransformDefinition.Load( Path.Combine(basePath, string.Format("{0}.json", name)), options); } return(definitions[name]); }
/// <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)); } } }