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);
}
}
}
