Example #1
0
        public void ExecuteSetCommandWithComplexDotExpression()
        {
            BindingEnvironment environment = new BindingEnvironment();
            DotExpression      dot         = new DotExpression(new VariableExpression("foo"), "Address");
            DotExpression      dotexpr     = new DotExpression(dot, "Street");
            SetCommand         command     = new SetCommand(dotexpr, new ConstantExpression("bar"));

            command.Execute(environment);

            object obj = environment.GetValue("foo");

            Assert.IsNotNull(obj);
            Assert.IsInstanceOfType(obj, typeof(DynamicObject));

            DynamicObject dynobj = (DynamicObject)obj;

            object obj2 = dynobj.GetValue("Address");

            Assert.IsNotNull(obj2);
            Assert.IsInstanceOfType(obj2, typeof(DynamicObject));

            DynamicObject dynobj2 = (DynamicObject)obj2;

            Assert.AreEqual("bar", dynobj2.GetValue("Street"));
        }
Example #2
0
        public static string EvaluateAsName(IExpression expression, ValueEnvironment environment)
        {
            if (expression == null)
            {
                return(null);
            }

            if (expression is NameExpression)
            {
                return(((NameExpression)expression).Name);
            }

            if (expression is DotExpression)
            {
                DotExpression dot = (DotExpression)expression;

                return(EvaluateAsName(dot.Expression, environment) + "." + dot.Name);
            }

            object result = expression.Evaluate(environment);

            if (result == null)
            {
                return(null);
            }

            return(result.ToString());
        }
        public void NamedExpression()
        {
            INamedExpression expression = new DotExpression(new ConstantExpression(1), "class", null);

            Assert.AreEqual(new ConstantExpression(1), expression.TargetExpression);
            Assert.AreEqual("class", expression.Name);
        }
Example #4
0
        public void ExecuteSetArrayCommandWithDotExpression()
        {
            BindingEnvironment environment = new BindingEnvironment();
            DotExpression      dotexpr     = new DotExpression(new VariableExpression("foo"), "Values");
            SetArrayCommand    command     = new SetArrayCommand(dotexpr, new IExpression[] { new ConstantExpression(0) }, new ConstantExpression("bar"));

            command.Execute(environment);

            object obj = environment.GetValue("foo");

            Assert.IsNotNull(obj);
            Assert.IsInstanceOfType(obj, typeof(DynamicObject));

            DynamicObject dynobj = (DynamicObject)obj;

            object obj2 = dynobj.GetValue("Values");

            Assert.IsNotNull(obj2);
            Assert.IsInstanceOfType(obj2, typeof(IList));

            IList list = (IList)obj2;

            Assert.AreEqual(1, list.Count);
            Assert.AreEqual("bar", list[0]);
        }
Example #5
0
        private IExpression ParseSimpleNameExpression(Token token)
        {
            IExpression expr = new NameExpression(token.Value);

            while (this.TryParseToken(TokenType.Delimiter, "."))
            {
                expr = new DotExpression(expr, this.ParseName());
            }

            if (!this.TryParseToken(TokenType.Delimiter, "("))
            {
                return(expr);
            }

            IList <IExpression> argexprs = new List <IExpression>();

            while (!this.TryParseToken(TokenType.Delimiter, ")"))
            {
                if (argexprs.Count > 0)
                {
                    this.ParseToken(TokenType.Delimiter, ",");
                }

                argexprs.Add(this.ParseExpression());
            }

            if (expr is DotExpression)
            {
                return(new CallDotExpression((DotExpression)expr, argexprs));
            }

            return(new CallExpression(token.Value, argexprs));
        }
Example #6
0
        private IExpression ParseTermExpression()
        {
            IExpression expression = this.ParseSimpleTermExpression();

            while (this.TryParse(TokenType.Operator, ".") || this.TryParse(TokenType.Separator, "[", "("))
            {
                if (this.TryParse(TokenType.Separator, "("))
                {
                    expression = new InvokeExpressionExpression(expression, this.ParseArgumentList());
                }
                else if (this.TryParse(TokenType.Operator, "."))
                {
                    this.lexer.NextToken();
                    string             name      = this.ParseName();
                    List <IExpression> arguments = null;

                    if (this.TryParse(TokenType.Separator, "("))
                    {
                        arguments = this.ParseArgumentList();
                    }

                    expression = new DotExpression(expression, name, arguments);
                }
                else
                {
                    expression = new ArrayExpression(expression, this.ParseArrayArgumentList());
                }
            }

            return(expression);
        }
Example #7
0
        public void CreateDotExpression()
        {
            IExpression lexpr = new ConstantExpression(1);

            var expr = new DotExpression(lexpr, "Foo");

            Assert.AreEqual("Foo", expr.Name);
            Assert.AreSame(lexpr, expr.Expression);
        }
Example #8
0
        public void DefineAndEvaluateDotExpression()
        {
            DotExpression expr = new DotExpression(new ConstantExpression(new MockObject()), "foo", null);

            object result = expr.Evaluate(null);

            Assert.IsNotNull(result);
            Assert.AreEqual("foo", result);
        }
Example #9
0
        public void CreateAssignDotCommand()
        {
            DotExpression        leftvalue = (DotExpression)(new Parser("a.b")).ParseExpression();
            IExpression          value     = new ConstantExpression(1);
            AssignDotExpressions cmd       = new AssignDotExpressions(leftvalue, value);

            Assert.AreSame(leftvalue, cmd.LeftValue);
            Assert.AreSame(value, cmd.Expression);
        }
Example #10
0
        public void CreateDotExpressionWithQualifiedName()
        {
            IExpression nexpr = new DotExpression(new NameExpression("Bar"), "Foo");

            var expr = new DotExpression(nexpr, "Doo");

            Assert.AreEqual("Doo", expr.Name);
            Assert.AreEqual("Bar.Foo.Doo", expr.FullName);
            Assert.AreSame(nexpr, expr.Expression);
        }
Example #11
0
        public void ParseCallWithBlockWithArguments()
        {
            Parser parser   = new Parser("1.upto(9) { |x| print x }");
            var    expected = new DotExpression(new ConstantExpression(1), "upto", new IExpression[] { new ConstantExpression(9), new BlockExpression(new string[] { "x" }, new CallExpression("print", new IExpression[] { new NameExpression("x") })) });
            var    result   = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseCommand());
        }
        public void EvaluateNativeObjectClassMethod()
        {
            Machine machine = new Machine();

            DotExpression expression = new DotExpression(new ConstantExpression(1), "class", null);

            var result = expression.Evaluate(machine.RootContext);

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(FixnumClass));
        }
        private static void SetValue(DotExpression expression, object value, IContext context)
        {
            if (expression.Arguments != null)
            {
                throw new InvalidOperationException("Invalid left value");
            }

            object obj = ResolveToObject(expression.Expression, context);

            ObjectUtilities.SetValue(obj, expression.Name, value);
        }
Example #14
0
        public void ParseChainedDot()
        {
            Parser parser   = new Parser("Object.new.class");
            var    expected = new DotExpression(new DotExpression(new NameExpression("Object"), "new", new IExpression[] { }), "class", new IExpression[] { });
            var    result   = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseCommand());
        }
Example #15
0
        public void ParseCallWithBlock()
        {
            Parser parser   = new Parser("k.times { print 'foo' }");
            var    expected = new DotExpression(new NameExpression("k"), "times", new IExpression[] { new BlockExpression(null, new CallExpression("print", new IExpression[] { new ConstantExpression("foo") })) });
            var    result   = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseCommand());
        }
Example #16
0
        public object Visit(DotExpression dotExpression)
        {
            PrintStart(".", ConsoleColor.Magenta);
            foreach (var expression in dotExpression.Expressions)
            {
                Next(expression);
            }
            _indentationLevel--;

            return(null !);
        }
Example #17
0
        public void ParseDotExpressionWithTwoArgumentsInParentheses()
        {
            Parser parser   = new Parser("dog.foo('foo', 'bar')");
            var    expected = new DotExpression(new NameExpression("dog"), "foo", new IExpression[] { new ConstantExpression("foo"), new ConstantExpression("bar") });

            var result = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseExpression());
        }
Example #18
0
        public void EvaluateDotExpression()
        {
            Context     parent  = new Context();
            Context     context = new Context(parent);
            IExpression lexpr   = new ConstantExpression(context);

            var expr  = new DotExpression(lexpr, "Parent");
            var value = expr.Evaluate(null);

            Assert.IsNotNull(value);
            Assert.AreSame(parent, value);
        }
Example #19
0
        public void ParseDotExpressionWithIntegerArgument()
        {
            Parser parser   = new Parser("dog.foo 1");
            var    expected = new DotExpression(new NameExpression("dog"), "foo", new IExpression[] { new ConstantExpression(1) });

            var result = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseExpression());
        }
Example #20
0
        public void ParseSimpleDotExpressionWithNoArguments()
        {
            IExpression expression = ParseExpression("foo.Bar()");

            Assert.IsNotNull(expression);
            Assert.IsInstanceOfType(expression, typeof(DotExpression));

            DotExpression dotexp = (DotExpression)expression;

            Assert.IsNotNull(dotexp.Arguments);
            Assert.AreEqual(0, dotexp.Arguments.Count);
        }
Example #21
0
        public void ParseDotExpression()
        {
            Parser parser   = new Parser("dog.foo");
            var    expected = new DotExpression(new NameExpression("dog"), "foo", new IExpression[0]);

            var result = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseExpression());
        }
Example #22
0
        public void ParseDotExpressionWithIntegerAsTarget()
        {
            Parser parser   = new Parser("1.foo");
            var    expected = new DotExpression(new ConstantExpression(1), "foo", new IExpression[0]);

            var result = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseExpression());
        }
Example #23
0
        public void ParseAssignDotCommand()
        {
            Parser        parser   = new Parser("a.b = 2");
            DotExpression dotexpr  = (DotExpression)(new Parser("a.b")).ParseExpression();
            var           expected = new AssignDotExpressions(dotexpr, new ConstantExpression(2));
            var           result   = parser.ParseCommand();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseCommand());
        }
Example #24
0
        public void DefineAndEvaluateDotExpressionWithArguments()
        {
            List <IExpression> arguments = new List <IExpression>();

            arguments.Add(new ConstantExpression(1));
            arguments.Add(new ConstantExpression(2));
            DotExpression expr = new DotExpression(new ConstantExpression(new MockObject()), "foo", arguments);

            object result = expr.Evaluate(null);

            Assert.IsNotNull(result);
            Assert.AreEqual("foo:1:2", result);
        }
Example #25
0
        private IExpression ParseComplexName()
        {
            string name = this.ParseName();

            IExpression expression = new NameExpression(name);

            while (this.TryParse(".", TokenType.Operator))
            {
                expression = new DotExpression(expression, this.ParseName());
            }

            return(expression);
        }
Example #26
0
        public void CreateCallDotExpression()
        {
            DotExpression       dotexpr = new DotExpression(new NameExpression("foo"), "bar");
            IList <IExpression> exprs   = new List <IExpression>()
            {
                new ConstantExpression(1), new ConstantExpression(2)
            };

            var expr = new CallDotExpression(dotexpr, exprs);

            Assert.AreEqual(dotexpr, expr.Expression);
            Assert.AreSame(exprs, expr.ArgumentExpressions);
        }
Example #27
0
        public void ParseDotExpression()
        {
            Parser parser = new Parser("a.length");
            var    result = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.That(result is DotExpression);

            DotExpression expression = (DotExpression)result;

            Assert.AreEqual("length", expression.Name);
            Assert.IsNull(expression.Arguments);
            Assert.That(expression.Expression is VariableExpression);
        }
Example #28
0
        public void ParseDotExpression()
        {
            Parser parser = new Parser("a.length");
            var    result = parser.ParseExpression();

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(DotExpression));

            DotExpression expression = (DotExpression)result;

            Assert.AreEqual("length", expression.Name);
            Assert.IsNull(expression.Arguments);
            Assert.IsInstanceOfType(expression.Expression, typeof(VariableExpression));
        }
        public void GetName()
        {
            IObject dobj    = new DynamicObject("Name", "Adam", "Age", 800);
            Context context = new Context();

            context.SetMember("adam", dobj);

            DotExpression expression = new DotExpression(new NameExpression("adam"), "Name");

            var result = expression.Evaluate(context);

            Assert.IsNotNull(result);
            Assert.AreEqual("Adam", result);
        }
Example #30
0
        private static DotExpression ExpandQuasiquote(DotExpression expression)
        {
            Func <DotExpression, bool> isPair =
                exp => exp is DotList l && l.Expressions.Count != 0;

            if (!isPair(expression)) // `x => 'x
            {
                var quotedExpr = new LinkedList <DotExpression>();
                quotedExpr.AddLast(new DotSymbol("quote", expression.Line,
                                                 expression.Column));
                quotedExpr.AddLast(expression);

                return(quotedExpr.ToDotList());
            }

            var list = (expression as DotList).Expressions;

            if (list.First() is DotSymbol ds && ds.Name == "unquote")
            {
                return(list.ElementAt(1));
            }

            if (isPair(expression) &&
                (list.First() is DotList uqList) &&
                (uqList.Expressions.First() as DotSymbol).Name ==
                "unquotesplicing")
            {
                var first  = uqList.Expressions.Skip(1).First();
                var others = list.Skip(1).ToDotList();

                var expandedSplice = new LinkedList <DotExpression>();

                expandedSplice.AddLast(new DotSymbol("concat", expression.Line,
                                                     expression.Column));
                expandedSplice.AddLast(first);
                expandedSplice.AddLast(ExpandQuasiquote(others));

                return(expandedSplice.ToDotList());
            }

            var ret = new LinkedList <DotExpression>();

            ret.AddLast(new DotSymbol("cons", expression.Line, expression.Column));
            ret.AddLast(ExpandQuasiquote(list.First()));
            var rest = list.Skip(1).ToDotList();

            ret.AddLast(ExpandQuasiquote(rest));

            return(ret.ToDotList());
        }
 /**
  * Call back method that must be called as soon as the given <code>
  * DotExpression</code> object has been traversed.
  *
  * @param pDotExpression  The <code>DotExpression</code> object that has
  *                        just been traversed.
  */
 public void actionPerformed(
      DotExpression pDotExpression)
 {
     // Nothing to do.
 }
 /**
  * Call back method that must be called when the given <code>DotExpression
  * </code> will become the next <i>traverse candidate</i>.
  *
  * @param pDotExpression  The <code>DotExpression</code> object that will
  *                        become the next <i>traverse candidate</i>.
  */
 public void performAction(
      DotExpression pDotExpression)
 {
     // Nothing to do.
 }