private static IEnumerable <Snippet> BuildSnippets(Binding binding, BindingPrefixReference prefix, ElementNode element)
        {
            // this reference can use all attributes that start with it's prefix
            var candidates = element.Attributes
                             .Where(attr => attr.Name.StartsWith(prefix.Prefix ?? ""));

            // attributes that are matched by name, or by a longer prefix, no longer remain
            var remaining = candidates
                            .Where(attr => AllNodes(binding).Any(compare => TestBetterMatch(attr.Name, prefix.Prefix, compare)) == false);

            // remaining attributes have a name that doesn't include the prefix characters
            var attrs = remaining
                        .Select(attr => new { PropertyName = attr.Name.Substring((prefix.Prefix ?? "").Length), Attribute = attr });

            var results = new List <Snippet>();

            if (prefix.AssumeDictionarySyntax)
            {
                results.Add(new Snippet {
                    Value = "{"
                });
            }

            var first = true;

            foreach (var attr in attrs)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    results.Add(new Snippet {
                        Value = ","
                    });
                }

                if (prefix.AssumeDictionarySyntax)
                {
                    results.Add(new Snippet {
                        Value = "{\"" + attr.PropertyName + "\","
                    });
                }
                else
                {
                    results.Add(new Snippet {
                        Value = attr.PropertyName + "="
                    });
                }

                if (prefix.AssumeStringValue)
                {
                    var builder = new ExpressionBuilder();
                    PopulateBuilder(attr.Attribute.Nodes, builder);
                    results.Add(new Snippet {
                        Value = builder.ToCode()
                    });
                }
                else
                {
                    results.AddRange(attr.Attribute.AsCode());
                }

                if (prefix.AssumeDictionarySyntax)
                {
                    results.Add(new Snippet {
                        Value = "}"
                    });
                }
            }

            if (prefix.AssumeDictionarySyntax)
            {
                results.Add(new Snippet {
                    Value = "}"
                });
            }

            return(results);
        }
Exemple #2
0
        private static IEnumerable <Snippet> BuildSnippets(Binding binding, BindingPrefixReference prefix, ElementNode element)
        {
            var enumerable3 = from attr in element.Attributes
                              where attr.Name.StartsWith(prefix.Prefix ?? "")
                              where !AllNodes(binding).Any <BindingNode>(compare => TestBetterMatch(attr.Name, prefix.Prefix, compare))
                              select new { PropertyName = attr.Name.Substring((prefix.Prefix ?? "").Length), Attribute = attr };
            List <Snippet> list = new List <Snippet>();

            if (prefix.AssumeDictionarySyntax)
            {
                Snippet item = new Snippet {
                    Value = "{"
                };
                list.Add(item);
            }
            bool flag = true;

            foreach (var type in enumerable3)
            {
                if (flag)
                {
                    flag = false;
                }
                else
                {
                    Snippet snippet = new Snippet {
                        Value = ","
                    };
                    list.Add(snippet);
                }
                if (prefix.AssumeDictionarySyntax)
                {
                    Snippet snippet3 = new Snippet {
                        Value = "{\"" + type.PropertyName + "\","
                    };
                    list.Add(snippet3);
                }
                else
                {
                    Snippet snippet4 = new Snippet {
                        Value = type.PropertyName + "="
                    };
                    list.Add(snippet4);
                }
                if (prefix.AssumeStringValue)
                {
                    ExpressionBuilder builder = new ExpressionBuilder();
                    PopulateBuilder(type.Attribute.Nodes, builder);
                    Snippet snippet2 = new Snippet {
                        Value = builder.ToCode()
                    };
                    list.Add(snippet2);
                }
                else
                {
                    list.AddRange(type.Attribute.AsCode());
                }
                if (prefix.AssumeDictionarySyntax)
                {
                    Snippet snippet5 = new Snippet {
                        Value = "}"
                    };
                    list.Add(snippet5);
                }
            }
            if (prefix.AssumeDictionarySyntax)
            {
                Snippet snippet7 = new Snippet {
                    Value = "}"
                };
                list.Add(snippet7);
            }
            return(list);
        }