コード例 #1
0
        public void TwoSimpleExpressionParameter()
        {
            var param1 = new UIHintParameterValue("ipsum");
            var param2 = new UIHintParameterValue("dolor");
            var parameterValueParser = Mock.Of <IUIHintParameterValueParser>();

            Mock.Get(parameterValueParser).Setup(p => p.Parse(It.IsAny <IParser>())).Returns <IParser>(p => {
                if (p.IsThenSkip("ipsum"))
                {
                    return(param1);
                }

                if (p.IsThenSkip("dolor"))
                {
                    return(param2);
                }

                throw new Exception($"Unknown input at {p}");
            });

            var result = new UIHintParser(parameterValueParser).Parse("lorem(ipsum, dolor)");

            Assert.Equal("lorem", result.Id);
            Assert.Equal(2, result.Parameters.Count);
        }
コード例 #2
0
        public void OneParameter()
        {
            var param = new UIHintParameterValue("ipsum");
            var parameterValueParser = Mock.Of <IUIHintParameterValueParser>();

            Mock.Get(parameterValueParser).Setup(p => p.Parse(It.IsAny <IParser>())).Returns <IParser>(p => {
                if (p.IsThenSkip("ipsum"))
                {
                    return(param);
                }

                throw new Exception("Unknown input");
            });
            var result = new UIHintParser(parameterValueParser).Parse("lorem(ipsum)");

            Assert.Equal("lorem", result.Id);
            Assert.Single(result.Parameters);
            Assert.Same(param, result.Parameters.Single());
        }
コード例 #3
0
        UIHintParameterValue ParseObject(Parser parser)
        {
            var instance = new Dictionary <string, UIHintParameterValue>();

            parser.SkipWhitespace();
            parser.Expect('{');
            parser.Skip();

            parser.SkipWhitespace();
            while (!parser.Is('}'))
            {
                parser.SkipWhitespace();

                string key;

                if (parser.Is('\''))
                {
                    parser.Skip();
                    key = parser.ReadUntil('\'');

                    parser.Expect('\'');
                    parser.Skip();
                }
                else
                {
                    key = parser.ReadUntil(':', ',', '}');
                }

                parser.SkipWhitespace();

                if (parser.Is(',', '}'))
                {
                    var value = new Expression(new List <ExpressionSegment>
                    {
                        new ExpressionSegment(ExpressionSegmentType.Interpolated, key),
                    });

                    instance[key] = new UIHintParameterValue(value);
                }
                else
                {
                    parser.Expect(':');
                    parser.Skip();

                    parser.SkipWhitespace();

                    instance[key] = ParseParameter(parser);
                }

                parser.SkipWhitespace();

                if (parser.Is('}'))
                {
                    break;
                }

                parser.Expect(',');
                parser.Skip();
            }

            parser.Expect('}');
            parser.Skip();

            return(new UIHintParameterValue(instance));
        }