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")); }
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); }
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]); }
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)); }
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); }
public void CreateDotExpression() { IExpression lexpr = new ConstantExpression(1); var expr = new DotExpression(lexpr, "Foo"); Assert.AreEqual("Foo", expr.Name); Assert.AreSame(lexpr, expr.Expression); }
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); }
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); }
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); }
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); }
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()); }
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()); }
public object Visit(DotExpression dotExpression) { PrintStart(".", ConsoleColor.Magenta); foreach (var expression in dotExpression.Expressions) { Next(expression); } _indentationLevel--; return(null !); }
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()); }
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); }
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()); }
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); }
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()); }
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()); }
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()); }
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); }
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); }
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); }
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); }
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); }
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. }