public override void Parse(ItemParseContext context, ITextNode textNode) { var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode); var parentItemPath = textNode.GetAttributeValue("ParentItemPath", context.ParentItemPath); var itemIdOrPath = PathHelper.CombineItemPath(parentItemPath, itemNameTextNode.Value); var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath)); var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName); var templateIdOrPath = textNode.Key.UnescapeXmlElementName(); var item = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, guid, databaseName, itemNameTextNode.Value, itemIdOrPath, templateIdOrPath); item.ItemNameProperty.AddSourceTextNode(itemNameTextNode); item.TemplateIdOrPathProperty.AddSourceTextNode(new AttributeNameTextNode(textNode)); item.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase); item.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsExtern, context.IsExtern.ToString()), "True", StringComparison.OrdinalIgnoreCase); if (!item.IsImport) { item.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(item, item.TemplateIdOrPathProperty)); } var fieldContext = new LanguageVersionContext(); ParseAttributes(context, item, fieldContext, textNode); ParseChildNodes(context, item, textNode); context.ParseContext.Project.AddOrMerge(item); }
public virtual SourceProperty <T> AddAdditionalSourceTextNode([CanBeNull] ITextNode textNode) { if (Locking == Locking.ReadOnly) { throw new InvalidOperationException("SourceProperty cannot be modified as it is read only: " + Key); } if (textNode == TextNode.Empty || textNode == null) { return(this); } if (SourceTextNode == TextNode.Empty) { SourceTextNode = textNode; return(this); } if (!AdditionalSourceTextNodes.Contains(textNode)) { _additionalSourceTextNodes.Add(textNode); } return(this); }
public AssertException([Localizable(true), NotNull] string text, [NotNull] ITextNode textNode, [NotNull] string details = "") : base(text + (string.IsNullOrEmpty(details) ? ": " + details : string.Empty)) { Text = text; FileName = textNode.Snapshot.SourceFile.AbsoluteFileName; Span = textNode.TextSpan; Details = details; }
public Item Build([NotNull] IProjectBase project, [NotNull] ITextNode rootTextNode) { var guid = StringHelper.GetGuid(project, Guid); var database = project.GetDatabase(DatabaseName); var item = Factory.Item(database, guid, ItemName, ItemIdOrPath, TemplateIdOrPath).With(rootTextNode); if (ItemNameTextNode != TextNode.Empty) { item.ItemNameProperty.AddSourceTextNode(ItemNameTextNode); } if (TemplateIdOrPathTextNode != TextNode.Empty) { item.TemplateIdOrPathProperty.AddSourceTextNode(TemplateIdOrPathTextNode); } item.IconProperty.SetValue(IconTextNode); foreach (var fieldBuilder in Fields) { var field = fieldBuilder.Build(item); item.Fields.Add(field); } return(item); }
public override void Parse(ItemParseContext context, ITextNode textNode) { var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode); var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value); var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath)); var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName); var templateIdOrPathTextNode = textNode.GetAttribute("Template"); var templateIdOrPath = templateIdOrPathTextNode?.Value ?? string.Empty; var item = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, guid, databaseName, itemNameTextNode.Value, itemIdOrPath, templateIdOrPath); item.ItemNameProperty.AddSourceTextNode(itemNameTextNode); item.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase); item.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsExtern, context.IsExtern.ToString()), "True", StringComparison.OrdinalIgnoreCase); if (templateIdOrPathTextNode != null) { item.TemplateIdOrPathProperty.AddSourceTextNode(templateIdOrPathTextNode); if (!item.IsImport) { item.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(item, item.TemplateIdOrPathProperty)); } } context.ParseContext.PipelineService.Resolve<ItemParserPipeline>().Execute(context, item, textNode); ParseChildNodes(context, item, textNode); context.ParseContext.Project.AddOrMerge(item); }
private void ParseFields([NotNull] Item item, [NotNull] ITextNode textNode, [NotNull] LanguageVersionContext fieldContext) { foreach (var fieldNode in textNode.ChildNodes.Where(n => n.Key == "ID")) { var fieldName = fieldNode.GetAttribute("Hint"); if (fieldName == null) { Trace.TraceError(Msg.P1038, "'Hint' attribute expected", fieldNode); continue; } var fieldValue = fieldNode.GetAttribute("Value"); if (fieldValue == null) { Trace.TraceError(Msg.P1039, "'Value' attribute expected", fieldNode); continue; } var field = Factory.Field(item).With(fieldNode); field.FieldNameProperty.SetValue(fieldName); field.ValueProperty.SetValue(fieldValue); field.LanguageProperty.SetValue(fieldContext.LanguageProperty); field.VersionProperty.SetValue(fieldContext.VersionProperty); item.Fields.Add(field); } }
protected TextNodeSourcePropertyBag WithSourceTextNode([NotNull] ITextNode textNode) { _sourceTextNodes.Remove(textNode); _sourceTextNodes.Insert(0, textNode); return(this); }
public static void Merge([NotNull, ItemNotNull] this IList <ITextNode> list1, [NotNull] ITextNode first1, [NotNull, ItemNotNull] IEnumerable <ITextNode> list2, [NotNull] ITextNode first2, bool overwrite) { foreach (var textNode in list2) { if (!list1.Contains(textNode)) { list1.Add(textNode); } } var first = TextNode.Empty; if (first1 != TextNode.Empty && first2 != TextNode.Empty) { first = overwrite ? first2 : first1; } else if (first1 != TextNode.Empty) { first = first1; } else if (first2 != TextNode.Empty) { first = first2; } if (first == TextNode.Empty) { return; } list1.Remove(first); list1.Insert(0, first); }
protected TextView(ITextNode node, IStyle style) { Node = node; Style = style; TextStyles = Style.StyleSystem.StylesFor <TextStyleDefinition>(); }
protected virtual string GetText([NotNull] ITextNode textNode) { var texts = new List <string>(); var itemName = textNode.GetAttributeValue("name"); if (!string.IsNullOrEmpty(itemName)) { texts.Add("named '" + itemName + "'"); } var templateName = textNode.GetAttributeValue("template"); if (!string.IsNullOrEmpty(templateName)) { texts.Add("with template '" + templateName + "'"); } var itemPath = textNode.GetAttributeValue("path"); if (!string.IsNullOrEmpty(itemPath)) { texts.Add("with path '" + itemPath + "'"); } return(string.Join(" and ", texts)); }
private static void PostDeserialize(ITextNode node) { switch (node.Value) { case IVisualElement visualElement: var current = node.Parent; if (!ReferenceEquals(current, NullNode.Instance) && current?.Value is IVisualContainer container) { if (container.Children.Contains(visualElement)) { container.OnChildDeserialized(visualElement, node); } } else if (current == null) { } else { //current = current.Parent; } break; } foreach (var kvp in node.Children.Values) { PostDeserialize(kvp); } }
public static ITreePath <ITextNode> CreatePathForNodeAt(this ITextNode node, int offset) { if (!node.InRange(offset)) { throw new ArgumentOutOfRangeException(nameof(offset), offset, null); } ITreePath <ITextNode> path = new TreePath <ITextNode>(node); for (var idx = 0; idx < node.Count;) { var child = node[idx]; if (child.InRange(offset)) { path = path.Append(child); // restart for-loop for the new node .. // this is a stack-friendly tail recursion. node = child; idx = 0; } else { idx += 1; } } return(path); }
public FieldBuilder With([NotNull] ItemBuilder itemBuilder, [NotNull] ITextNode fieldTextNode) { ItemBuilder = itemBuilder; FieldTextNode = fieldTextNode; return(this); }
public virtual void ParseChildNodes([NotNull] ItemParseContext context, [NotNull] ITextNode textNode) { foreach (var childNode in textNode.ChildNodes) { ParseTextNode(context, childNode); } }
public IEnumerable <Tuple <IStyle, IVisualElement> > GetStyles(ITextNode node) { //if (node.Attributes.TryGetValue(nameof(Style), out var styleName)) if (node.TryGetAttribute(nameof(Style), false, out var styleName)) { switch (node.Value) { case IVisualElement visualElement: if (TryGetElementStyle(visualElement, styleName.Value, out var found)) { yield return(new Tuple <IStyle, IVisualElement>(found, visualElement)); } break; default: throw new NotImplementedException(); } } foreach (var kvp in node.Children.Values) { foreach (var style in GetStyles(kvp)) { yield return(style); } } }
protected virtual void GetName([NotNull] IParseContext context, [NotNull] ITextNode sourceTextNode, [NotNull] out string name, [NotNull] out ITextNode nameTextNode, [NotNull] string elementName, [NotNull] string nameAttribute) { name = sourceTextNode.Key; if (!string.Equals(name, elementName, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(name)) { nameTextNode = new AttributeNameTextNode(sourceTextNode); return; } name = sourceTextNode.Value; if (!string.IsNullOrEmpty(name)) { nameTextNode = sourceTextNode; return; } var attr = sourceTextNode.GetAttribute(nameAttribute); if (attr != null) { name = attr.Value; nameTextNode = attr; return; } name = context.ItemName; nameTextNode = new FileNameTextNode(context.ItemName, sourceTextNode.Snapshot); }
protected virtual IEnumerable <ITextNode> GetSchemaChildNodes([NotNull] ITextNode schemaTextNode) { foreach (var childNode in schemaTextNode.ChildNodes) { switch (childNode.Key) { case "item": yield return(childNode); break; case "element": var refs = childNode.GetAttributeValue("ref"); if (string.IsNullOrEmpty(refs)) { throw new InvalidOperationException($"'ref' attribute expected at {childNode.Snapshot.SourceFile.AbsoluteFileName} {childNode.TextSpan}"); } foreach (var textNode in GetRefs(childNode, refs)) { yield return(textNode); } break; default: throw new InvalidOperationException($"Unexpected schema element '{childNode.Key} at {childNode.Snapshot.SourceFile.AbsoluteFileName} {childNode.TextSpan}"); } } }
public static void CheckInRange(this ITextNode node, string parameter, int offset) { if (InRange(node, offset)) { throw new ArgumentOutOfRangeException(parameter, offset, FormatMessage(node, parameter, offset)); } }
public static bool InRange(this ITextNode node, int offset) { if (offset < node.Offset || offset >= node.EndOffset) { return(false); } return(true); }
protected override void WriteRendering(LayoutCompileContext context, XmlTextWriter output, IEnumerable<Item> renderingItems, ITextNode renderingTextNode, string placeholders) { var childNode = renderingTextNode.ChildNodes.FirstOrDefault(); if (childNode != null) { base.WriteRendering(context, output, renderingItems, childNode, placeholders); } }
public void Execute([NotNull] ItemParseContext context, [NotNull] Template template, [NotNull] ITextNode textNode) { Context = context; Template = template; TextNode = textNode; Execute(); }
protected override void ParseRenderingReferences(ItemParseContext context, ICollection<IReference> references, IProjectItem projectItem, ITextNode renderingTextNode) { var childNode = renderingTextNode.ChildNodes.FirstOrDefault(); if (childNode != null) { base.ParseRenderingReferences(context, references, projectItem, childNode); } }
public void Execute([NotNull] ItemParseContext context, [NotNull] Item item, [NotNull] ITextNode textNode) { Context = context; Item = item; TextNode = textNode; Execute(); }
public virtual ITextView <PlainTextDocument> CreateFor(ITextNode node, IStyle style) { if (node.Leaf) { return(new ParagraphTextView <PlainTextDocument>(node, style, this)); } return(new BlockTextView <PlainTextDocument>(node, style)); }
public virtual ITextChunkView <PlainTextDocument> CreateChunkFor(ITextNode node, IStyle style) { var offset = node.Document.CreatePosition(node.Offset, Bias.Forward); var endOffset = node.Document.CreatePosition(node.EndOffset, Bias.Backward); var chunkView = new TextChunkView <PlainTextDocument>(TextProcessingRules, node, style, offset, endOffset); chunkView.Initialize(); return(chunkView); }
protected TextNodeSourcePropertyBag WithAdditionalSourceTextNode([NotNull] ITextNode textNode) { if (!_sourceTextNodes.Contains(textNode)) { _sourceTextNodes.Add(textNode); } return(this); }
protected override void ParseUnversionedTextNode(ItemParseContext context, Item item, ITextNode textNode) { foreach (var languageChildNode in textNode.ChildNodes) { var fieldContext = new LanguageVersionContext(); fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(languageChildNode)); ParseUnversionedOrVersionedTreeNode(context, item, fieldContext, languageChildNode); } }
public static void CheckInRange(this ITextNode node, int offset, int endOffset) { CheckInRange(node, nameof(offset), offset); CheckInEndOffsetRange(node, nameof(endOffset), endOffset); if (offset > endOffset) { throw new ArgumentOutOfRangeException($"Offset [{offset}] cannot be greater than end offset [{endOffset}]."); } }
public ParagraphTextView(ITextNode node, IStyle style, ITextNodeViewFactory <TDocument> viewFactory) : base(node, style) { this.viewFactory = viewFactory; lineMetrics = new List <LineMetrics>(); rawContent = new List <ITextChunkView <TDocument> >(); lineBreakContent = new List <PositionedChunk>(); lineWidth = -1; Dirty = true; }
public override ITextNode GetInnerTextNode() { var element = _node as XElement; if (element != null) { return _innerText ?? (_innerText = new XmlInnerTextNode(this, element)); } return null; }
public virtual bool ParseIfHasAttribute([NotNull] string newKey, [NotNull] ITextNode textNode) { if (Locking == Locking.ReadOnly) { throw new InvalidOperationException("SourceProperty cannot be modified as it is read only: " + Key); } Key = newKey; return(ParseIfHasAttribute(textNode)); }
public Reference([NotNull] IProjectItem owner, [NotNull] ITextNode textNode, [NotNull] string referenceText, [NotNull] string databaseName) { // the reference text might be different from the source property value. // e.g. the source property value might be a list of guids while the reference text is a single Guid. Owner = owner; SourceProperty = null; TextNode = textNode; ReferenceText = referenceText; DatabaseName = databaseName; }
protected override void ParseUnversionedTextNode(ItemParseContext context, Item item, ITextNode textNode) { var fieldContext = new LanguageVersionContext(); fieldContext.LanguageProperty.Parse(textNode); foreach (var unversionedChildNode in textNode.ChildNodes) { ParseFieldTextNode(context, item, fieldContext, unversionedChildNode); } }
public virtual void Parse([NotNull] string newKey, [NotNull] ITextNode textNode, [CanBeNull] T defaultValue = default(T)) { if (Locking == Locking.ReadOnly) { throw new InvalidOperationException("SourceProperty cannot be modified as it is read only: " + Key); } Key = newKey; Parse(textNode, defaultValue); }
public override void Parse(ItemParseContext context, ITextNode textNode) { var guid = GetGuid(textNode, "ID"); if (guid == Guid.Empty) { Trace.TraceError(Msg.P1035, "'ID' attribute is missing or invalid", textNode); return; } var templateGuid = GetGuid(textNode, "Template"); if (templateGuid == Guid.Empty) { Trace.TraceError(Msg.P1036, "'Template' attribute is missing or invalid", textNode); return; } var databaseName = textNode.GetAttributeValue("DB", context.Database.DatabaseName); var database = context.ParseContext.Project.GetDatabase(databaseName); var itemIdOrPath = textNode.GetAttributeValue("Path"); var itemName = Path.GetFileName(itemIdOrPath); var templateIdOrPath = templateGuid.Format(); var item = Factory.Item(database, guid, itemName, itemIdOrPath, templateIdOrPath).With(textNode); var sharedFieldContext = new LanguageVersionContext(); ParseFields(item, textNode, sharedFieldContext); foreach (var languageNode in textNode.ChildNodes.Where(n => n.Key == "Language")) { var unversionedFieldContext = new LanguageVersionContext(); unversionedFieldContext.LanguageProperty.SetValue(languageNode); ParseFields(item, languageNode, unversionedFieldContext); foreach (var versionNode in languageNode.ChildNodes.Where(n => n.Key == "Version")) { if (!int.TryParse(versionNode.Value, out var _)) { Trace.TraceError(Msg.P1037, "Version number must be an integer", versionNode); continue; } var versionedFieldContext = new LanguageVersionContext(); versionedFieldContext.LanguageProperty.SetValue(languageNode); versionedFieldContext.VersionProperty.SetValue(versionNode); ParseFields(item, versionNode, versionedFieldContext); } } context.ParseContext.Project.AddOrMerge(item); }
protected override void ParseFieldsTextNode(ItemParseContext context, Item item, ITextNode textNode) { var fieldContext = new LanguageVersionContext(); foreach (var attribute in textNode.Attributes) { ParseFieldTextNode(context, item, fieldContext, attribute); } base.ParseFieldsTextNode(context, item, textNode); }
protected override void ParseLayoutTextNode(ItemParseContext context, Item item, ITextNode textNode) { var childNode = textNode.ChildNodes.FirstOrDefault(); if (childNode == null) { return; } var parser = new XmlLayoutTextNodeParser(); parser.Parse(context, childNode, item); }
public ReferenceParserPipeline Execute([NotNull] IProjectItem projectItem, [NotNull] ITextNode sourceTextNode, [NotNull] string referenceText, [NotNull] IDatabase database) { ProjectItem = projectItem; SourceTextNode = sourceTextNode; ReferenceText = referenceText; Database = database; Execute(); return(this); }
private void UiBuilder_DisplayTextNode(ITextNode node) { if (node is TextFolderNode folderNode) { DisplayTextFolderNode(folderNode); } else if (node is TextEntryNode macroNode) { UiBuilder_DisplayTextEntryNode(macroNode); } }
protected override void ParseFieldTextNode(ItemParseContext context, Item item, LanguageVersionContext languageVersionContext, ITextNode textNode) { var fieldNameTextNode = string.IsNullOrEmpty(textNode.Value) ? textNode.GetAttribute("Name") : textNode; if (fieldNameTextNode == null) { context.ParseContext.Trace.TraceError(Msg.P1015, Texts.Expected__Name__attribute, textNode); return; } ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode); }
protected override void ParseUnversionedTextNode(ItemParseContext context, Item item, ITextNode textNode) { var firstChildNode = textNode.ChildNodes.First(); var fieldContext = new LanguageVersionContext(); fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(firstChildNode)); foreach (var unversionedChildNode in firstChildNode.ChildNodes) { ParseFieldTextNode(context, item, fieldContext, unversionedChildNode); } }
public override void Parse(ItemParseContext context, ITextNode textNode) { var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode); var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value); var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath)); var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName); var template = context.ParseContext.Factory.Template(context.ParseContext.Project, guid, textNode, databaseName, itemNameTextNode.Value, itemIdOrPath); template.ItemNameProperty.AddSourceTextNode(itemNameTextNode); template.BaseTemplatesProperty.Parse(textNode, Constants.Templates.StandardTemplate); template.IconProperty.Parse(textNode); template.ShortHelpProperty.Parse(textNode); template.LongHelpProperty.Parse(textNode); template.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase); template.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsExtern, context.IsExtern.ToString()), "True", StringComparison.OrdinalIgnoreCase); template.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(template, template.BaseTemplatesProperty)); // create standard values item var standardValuesItemIdOrPath = itemIdOrPath + "/__Standard Values"; var standardValuesGuid = StringHelper.GetGuid(context.ParseContext.Project, standardValuesItemIdOrPath); var standardValuesItem = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, standardValuesGuid, databaseName, "__Standard Values", standardValuesItemIdOrPath, itemIdOrPath); standardValuesItem.IsImport = template.IsImport; // todo: should be Uri template.StandardValuesItem = standardValuesItem; // parse fields and sections var sections = textNode.GetSnapshotLanguageSpecificChildNode("Sections"); if (sections != null) { foreach (var sectionTreeNode in sections.ChildNodes) { ParseSection(context, template, sectionTreeNode); } } // setup HtmlTemplate var htmlFileTextNode = textNode.GetAttribute("Layout.HtmlFile"); if (htmlFileTextNode != null && !string.IsNullOrEmpty(htmlFileTextNode.Value)) { var field = context.ParseContext.Factory.Field(template.StandardValuesItem, htmlFileTextNode); field.FieldNameProperty.SetValue("__Renderings"); field.ValueProperty.SetValue(htmlFileTextNode.Value); field.ValueHintProperty.SetValue("HtmlTemplate"); template.StandardValuesItem.Fields.Add(field); } context.ParseContext.Project.AddOrMerge(template); context.ParseContext.Project.AddOrMerge(standardValuesItem); }
public override void Parse(ItemParseContext context, ITextNode textNode) { var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode); var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value); var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath)); var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName); var item = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, guid, databaseName, itemNameTextNode.Value, itemIdOrPath, string.Empty); item.ItemNameProperty.AddSourceTextNode(itemNameTextNode); Parse(context, textNode, item); context.ParseContext.Project.AddOrMerge(item); }
protected override string GetPlaceholders(LayoutCompileContext context, ITextNode renderingTextNode, IProjectItem projectItem) { var childTextNode = renderingTextNode; /* if (childTextNode.ParentNode != null && childTextNode.ParentNode.Key == "Renderings") { childTextNode = childTextNode.ChildNodes.FirstOrDefault(); if (childTextNode == null) { return string.Empty; } } */ return base.GetPlaceholders(context, childTextNode, projectItem); }
protected override void TraceLine(ITraceService trace, int msg, string text, ITextNode textNode, ISnapshot snapshot, string details) { if (textNode != null) { trace.TraceInformation(msg, text, textNode, details); } else if (snapshot != null) { trace.TraceInformation(msg, text, snapshot.SourceFile, details); } else { trace.TraceInformation(msg, text, details); } }
protected override void ParseChildrenTextNodes(ItemParseContext context, Item item, ITextNode textNode) { foreach (var childNode in textNode.ChildNodes) { // id child node is blank and first child is "Item", then this is probably an File.Include item var child = childNode; if (string.IsNullOrEmpty(child.Key) && !child.Attributes.Any() && child.ChildNodes.Count() == 1 && child.ChildNodes.First().Key == "Item") { child = childNode.ChildNodes.First(); } var newContext = context.ParseContext.Factory.ItemParseContext(context.ParseContext, context.Parser, item.DatabaseName, PathHelper.CombineItemPath(context.ParentItemPath, item.ItemName), item.IsImport); Parse(newContext, child); } }
protected override void TraceLine(int msg, string text, ITextNode textNode, ISnapshot snapshot, string details) { if (textNode != null) { Trace.TraceError(msg, text, textNode, details); } else if (snapshot != null) { Trace.TraceError(msg, text, snapshot.SourceFile, details); } else { Trace.TraceError(msg, text, details); } }
public override IEnumerable<ITextNode> Parse(SnapshotParseContext snapshotParseContext, ITextNode textNode) { var key = textNode.GetAttributeValue("Key"); if (string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(textNode.Value)) { key = textNode.Value; } if (string.IsNullOrEmpty(key)) { key = string.Empty; } List<ITextNode> textNodes; return snapshotParseContext.PlaceholderTextNodes.TryGetValue(key, out textNodes) ? textNodes : Enumerable.Empty<ITextNode>(); }
protected override void ParseVersionedTextNode(ItemParseContext context, Item item, ITextNode textNode) { context.ParseContext.SchemaService.ValidateTextNodeSchema(textNode); foreach (var versionChildNode in textNode.ChildNodes) { var fieldContext = new LanguageVersionContext(); fieldContext.LanguageProperty.Parse(textNode); fieldContext.VersionProperty.Parse(versionChildNode); foreach (var versionedChildNode in versionChildNode.ChildNodes) { ParseFieldTextNode(context, item, fieldContext, versionedChildNode); } } }
protected override void ParseFieldTextNode(ItemParseContext context, Item item, LanguageVersionContext languageVersionContext, ITextNode textNode) { var fieldNameTextNode = textNode.Key == "Field" ? textNode.GetAttribute("Name") : new AttributeNameTextNode(textNode); if (fieldNameTextNode == null) { context.ParseContext.Trace.TraceError(Msg.P1014, Texts.Expected__Name__attribute, textNode); return; } if (textNode.Attributes.Any() || textNode.ChildNodes.Any()) { base.ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode); return; } base.ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode, textNode); }
public override void Parse(ItemParseContext context, ITextNode textNode) { var itemNameTextNode = GetItemNameTextNode(context.ParseContext, textNode); var itemIdOrPath = PathHelper.CombineItemPath(context.ParentItemPath, itemNameTextNode.Value); var guid = StringHelper.GetGuid(context.ParseContext.Project, textNode.GetAttributeValue("Id", itemIdOrPath)); var databaseName = textNode.GetAttributeValue("Database", context.DatabaseName); var template = context.ParseContext.Factory.Template(context.ParseContext.Project, guid, textNode, databaseName, itemNameTextNode.Value, itemIdOrPath); template.ItemNameProperty.AddSourceTextNode(itemNameTextNode); template.BaseTemplatesProperty.Parse(textNode, Constants.Templates.StandardTemplate); template.IconProperty.Parse(textNode); template.ShortHelpProperty.Parse(textNode); template.LongHelpProperty.Parse(textNode); // todo: yuck template.IsEmittable = !string.Equals(textNode.GetAttributeValue(Constants.Fields.IsEmittable), "False", StringComparison.OrdinalIgnoreCase); template.IsImport = string.Equals(textNode.GetAttributeValue(Constants.Fields.IsImport, context.IsImport.ToString()), "True", StringComparison.OrdinalIgnoreCase); template.References.AddRange(context.ParseContext.ReferenceParser.ParseReferences(template, template.BaseTemplatesProperty)); // create standard values item var standardValuesItemIdOrPath = itemIdOrPath + "/__Standard Values"; var standardValuesGuid = StringHelper.GetGuid(context.ParseContext.Project, standardValuesItemIdOrPath); var standardValuesItem = context.ParseContext.Factory.Item(context.ParseContext.Project, textNode, standardValuesGuid, databaseName, "__Standard Values", standardValuesItemIdOrPath, itemIdOrPath); standardValuesItem.IsImport = template.IsImport; // todo: should be Uri template.StandardValuesItem = standardValuesItem; // parse fields and sections var sections = textNode.GetSnapshotLanguageSpecificChildNode("Sections"); if (sections != null) { foreach (var sectionTreeNode in sections.ChildNodes) { ParseSection(context, template, sectionTreeNode); } } context.ParseContext.PipelineService.Resolve<TemplateParserPipeline>().Execute(context, template, textNode); context.ParseContext.Project.AddOrMerge(template); context.ParseContext.Project.AddOrMerge(standardValuesItem); }
protected override void ParseVersionedTextNode(ItemParseContext context, Item item, ITextNode textNode) { var firstChildNode = textNode.ChildNodes.First(); context.ParseContext.SchemaService.ValidateTextNodeSchema(firstChildNode); foreach (var node in firstChildNode.ChildNodes) { var fieldContext = new LanguageVersionContext(); fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(firstChildNode)); fieldContext.VersionProperty.SetValue(new AttributeNameTextNode(node)); foreach (var versionedChildNode in node.ChildNodes) { ParseFieldTextNode(context, item, fieldContext, versionedChildNode); } } }
public bool ValidateTextNodeSchema(ITextNode textNode, string textNodeName) { if (string.IsNullOrEmpty(textNode.Key)) { return true; } var result = true; HashSet<string> hashSet; if (!_schema.TryGetValue(textNodeName, out hashSet)) { _schema.TryGetValue(textNodeName + "-attributes", out hashSet); } if (hashSet != null) { foreach (var attribute in textNode.Attributes) { if (!hashSet.Contains(attribute.Key)) { Trace.TraceError("'" + textNode.Key + "' element has unexpected attribute", attribute, attribute.Key); result = false; } } } if (_schema.TryGetValue(textNodeName + "-childnodes", out hashSet)) { foreach (var childNode in textNode.ChildNodes) { if (!hashSet.Contains(childNode.Key)) { Trace.TraceError("'" + textNode.Key + "' element has unexpected child node", childNode, childNode.Key); result = false; } } } return result; }
public override bool CanParse(ItemParseContext context, ITextNode textNode) { return textNode.Key == "Layout" && textNode.Snapshot is YamlTextSnapshot && textNode.Snapshot.SourceFile.AbsoluteFileName.EndsWith(".layout.yaml", StringComparison.OrdinalIgnoreCase); }
protected override void ParseUnknownTextNode(ItemParseContext context, Item item, LanguageVersionContext languageVersionContext, ITextNode textNode) { var fieldNameTextNode = new AttributeNameTextNode(textNode); ParseFieldTextNode(context, item, languageVersionContext, textNode, fieldNameTextNode); }
public override bool CanParse(ItemParseContext context, ITextNode textNode) { return textNode.Key == "Item" && textNode.Snapshot is XmlTextSnapshot; }
public bool ValidateTextNodeSchema(ITextNode textNode) { return ValidateTextNodeSchema(textNode, textNode.Key); }
protected override void ParseFieldsTextNode(ItemParseContext context, Item item, ITextNode fieldsTextNode) { context.ParseContext.SchemaService.ValidateTextNodeSchema(fieldsTextNode); base.ParseFieldsTextNode(context, item, fieldsTextNode); }
protected override void ParseLayoutTextNode(ItemParseContext context, Item item, ITextNode textNode) { var parser = new XmlLayoutTextNodeParser(); parser.Parse(context, textNode, item); }
protected override void ParseVersionedTextNode(ItemParseContext context, Item item, ITextNode textNode) { context.ParseContext.SchemaService.ValidateTextNodeSchema(textNode); foreach (var languageChildNode in textNode.ChildNodes) { foreach (var versionChildNode in languageChildNode.ChildNodes) { var fieldContext = new LanguageVersionContext(); fieldContext.LanguageProperty.SetValue(new AttributeNameTextNode(languageChildNode)); fieldContext.VersionProperty.SetValue(new AttributeNameTextNode(versionChildNode)); ParseUnversionedOrVersionedTreeNode(context, item, fieldContext, versionChildNode); } } }