Example #1
0
        public static void AddItemWithSyntax(this ValueTable table, string key, string value)
        {
            // Create a new item and matching syntax
            var newSyntaxValue = new StringValueSyntax(value);
            var newValue       = new Value(value)
            {
                // TODO: MirrorSyntax = newSyntaxTable,
            };

            // Add the model to the parent table model
            table.Add(key, newValue);

            switch (table.MirrorSyntax)
            {
            case InlineTableSyntax inlineTableSyntax:
                // Add the new syntax to the parent table syntax
                var inlineTableItemSyntax = new InlineTableItemSyntax(
                    new KeyValueSyntax()
                {
                    EqualToken = SyntaxFactory.Token(TokenKind.Equal),
                    Key        = new KeySyntax(key),
                    Value      = newSyntaxValue,
                });

                inlineTableItemSyntax.AddLeadingWhitespace();
                inlineTableItemSyntax.KeyValue.EqualToken.AddLeadingWhitespace();
                inlineTableItemSyntax.KeyValue.EqualToken.AddTrailingWhitespace();

                // A comma can not be on the last item
                // Add a comma to the previous item
                var previousItem = inlineTableSyntax.Items.LastOrDefault();
                if (previousItem != null)
                {
                    previousItem.Comma = SyntaxFactory.Token(TokenKind.Comma);
                }

                inlineTableSyntax.Items.Add(inlineTableItemSyntax);
                break;

            default:
                throw new InvalidOperationException("Unknown Syntax on ValueList");
            }
        }
Example #2
0
        public void SetProperties(IDictionary <string, string> value)
        {
            ValueTable?values;

            if (_table.TryGetValue(Property_Properties, out var propertiesValues))
            {
                values = (ValueTable)propertiesValues.AsTable();
            }
            else
            {
                var newTableSyntax = new InlineTableSyntax()
                {
                    OpenBrace  = SyntaxFactory.Token(TokenKind.OpenBrace),
                    CloseBrace = SyntaxFactory.Token(TokenKind.CloseBrace),
                };
                values = new ValueTable()
                {
                    MirrorSyntax = newTableSyntax,
                };
                _table[Property_Properties] = new Value(values);

                // Add the new syntax to the parent table syntax
                switch (_table.MirrorSyntax)
                {
                case TableSyntaxBase tableSyntax:
                    tableSyntax.Items.Add(new KeyValueSyntax(Property_Properties, newTableSyntax));
                    break;

                default:
                    throw new InvalidOperationException("Unknown Syntax on ValueTable");
                }
            }

            // Add the new syntax to the parent table syntax
            // values.();
            switch (values.MirrorSyntax)
            {
            case InlineTableSyntax tableSyntax:
                // Replace all items
                while (tableSyntax.Items.ChildrenCount > 0)
                {
                    tableSyntax.Items.RemoveChildrenAt(0);
                }

                var index = 0;
                foreach (var item in value)
                {
                    bool isLastItem = index == value.Keys.Count - 1;
                    var  equalToken = SyntaxFactory.Token(TokenKind.Equal);
                    equalToken.AddLeadingWhitespace();
                    equalToken.AddTrailingWhitespace();
                    var newKeyValue = new KeyValueSyntax()
                    {
                        Key        = new KeySyntax(item.Key),
                        EqualToken = equalToken,
                        Value      = new StringValueSyntax(item.Value),
                    };
                    var newInlineTableItem = new InlineTableItemSyntax(newKeyValue)
                    {
                    };
                    if (!isLastItem)
                    {
                        newInlineTableItem.Comma = SyntaxFactory.Token(TokenKind.Comma);
                    }

                    // newInlineTableItem.LeadingTrivia = new List<SyntaxTrivia>() { SyntaxFactory.Whitespace() };
                    tableSyntax.Items.Add(newInlineTableItem);
                    index++;
                }
                break;

            default:
                throw new InvalidOperationException("Unknown Syntax on ValueList");
            }
        }