gobstones 0.0.1.1 → 0.0.2

data/spec/lang/commands/vaciar_tablero_cmd_spec.rb

@@ -1,13 +1,14 @@
 describe VaciarTablero do
 
-  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
-  let(:red) { Rojo.new }
+  let(:context) { clean_context }
 
-  it "should empty the board in the context" do
-    context.head.put red
+  it "empties the board in the context" do
+    context.head.put rojo
     vaciar_tablero = VaciarTablero.new
+
     vaciar_tablero.evaluate context
-    expect(context.board.empty?).to be_true
+
+    expect(context.board.empty?).to be true
   end
 
-end
+end

data/spec/lang/commands/while_cmd_spec.rb

@@ -1,37 +1,43 @@
 describe WhileCmd do
 
-  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
-  let(:while_block) { CmdBlock.new [Poner.new(Verde.new)] }
+  let(:context) { clean_context }
+  let(:while_block) { CommandBlock.new [Poner.new(verde)] }
 
   def condition(times)
-    cond = double('while condition')
-    expected_values = [True.new] * times + [False.new]
-    allow(cond).to receive(:evaluate).and_return(*expected_values)
-    cond
+    double('while condition').tap do |condition|
+      expected_values = [true_value] * times + [false_value]
+      allow(condition).to receive(:evaluate).and_return(*expected_values)
+    end
   end
 
-  it "should evaluate the command block until the condition is not satisfied" do
+  it "evaluates the command block until the condition is not satisfied" do
     while_cmd = WhileCmd.new condition(3), while_block
+
     while_cmd.evaluate context
-    expect(context.head.number_of_balls(Verde.new)).to eq(3)
+
+    expect(context.head.number_of_balls(verde)).to eq(3)
   end
 
-  it "should not evaluate the command block if the condition is not satisfied" do
+  it "does not evaluate the command block if the condition is false" do
     while_cmd = WhileCmd.new condition(0), while_block
+
     while_cmd.evaluate context
-    expect(context.head.are_there_balls?(Verde.new)).to be_false
+
+    expect(context.head.are_there_balls?(verde)).to be false
   end
 
-  it "should raise a type error if the condition is not boolean" do
-    while_cmd = WhileCmd.new Sur.new, while_block
+  it "fails by type error if the condition is not boolean" do
+    while_cmd = WhileCmd.new sur, while_block
+
     expect { while_cmd.evaluate context }
       .to raise_error(GobstonesTypeError, /is not a boolean/)
   end
 
-  it "should fail by stack overflow if the condition is always true" do
-    while_cmd = WhileCmd.new True.new, while_block
+  it "fails by stack overflow if the condition is always true" do
+    while_cmd = WhileCmd.new true_value, while_block
+
     expect { while_cmd.evaluate context }
       .to raise_error(GobstonesRuntimeError, /stack overflow/)
   end
 
-end
+end

data/spec/lang/definitions/no_return_statement_spec.rb

@@ -0,0 +1,10 @@
+describe NoReturnStatement do
+
+  let(:context) { clean_context }
+  let(:no_return_statement) { NoReturnStatement.new }
+
+  it "does nothing when evaluating on a context" do
+    expect { no_return_statement.evaluate context }.not_to change { context.head }
+  end
+
+end

data/spec/lang/definitions/var_tuple_spec.rb

@@ -0,0 +1,16 @@
+describe VarTuple do
+
+  let (:var_tuple) { VarTuple.new ['a'.to_var_name, 'b'.to_var_name, 'c'.to_var_name] }
+
+  it "returns its length" do
+    expect(var_tuple.length).to eq(3)
+  end
+
+  it "returns a variable at a given index" do
+    expect(var_tuple.variable_at(0)).to eq('a'.to_var_name)
+    expect(var_tuple.variable_at(1)).to eq('b'.to_var_name)
+    expect(var_tuple.variable_at(2)).to eq('c'.to_var_name)
+
+  end
+
+end

data/spec/lang/expressions/arithmetic_expressions_spec.rb

@@ -2,12 +2,12 @@ describe "arithmetic expressions" do
 
   describe Add do
 
-    it "should evaluate with two numbers" do
+    it "evaluates with two numbers" do
       add = Add.new(42.to_gbs_num, 23.to_gbs_num)
       expect(add.evaluate).to eq(65.to_gbs_num)
     end
 
-    it "should evaluate nested add expressions" do
+    it "evaluates nested add expressions" do
       add_4_8 = Add.new 4.to_gbs_num, 8.to_gbs_num
       add_12_15 = Add.new add_4_8, 15.to_gbs_num
       add_27_16 = Add.new add_12_15, 16.to_gbs_num
@@ -21,17 +21,17 @@ describe "arithmetic expressions" do
 
   describe Sub do
 
-    it "should evaluate with two numbers" do
+    it "evaluates with two numbers" do
       sub = Sub.new(42.to_gbs_num, 15.to_gbs_num)
       expect(sub.evaluate).to eq(27.to_gbs_num)
     end
 
-    it "should evaluate and return a negative result" do
+    it "evaluates returning a negative result" do
       sub = Sub.new(15.to_gbs_num, 42.to_gbs_num)
       expect(sub.evaluate).to eq(-27.to_gbs_num)
     end
 
-    it "should evaluate nested sub expressions" do
+    it "evaluates nested sub expressions" do
       sub_n1_n2 = Sub.new 42.to_gbs_num, 15.to_gbs_num
       sub = Sub.new sub_n1_n2, 8.to_gbs_num
 
@@ -42,12 +42,12 @@ describe "arithmetic expressions" do
 
   describe Mul do
 
-    it "should evaluate a simple mul" do
+    it "evaluates a simple mul" do
       mul = Mul.new(4.to_gbs_num, 8.to_gbs_num)
       expect(mul.evaluate).to eq(32.to_gbs_num)
     end
 
-    it "should evaluate a nested mul expression" do
+    it "evaluates a nested mul expression" do
       mul = Mul.new(-2.to_gbs_num, 4.to_gbs_num)
       expect(Mul.new(mul, 5.to_gbs_num).evaluate).to eq(-40.to_gbs_num)
     end
@@ -56,17 +56,17 @@ describe "arithmetic expressions" do
 
   describe Div do
 
-    it "should evaluate a simple div" do
+    it "evaluates a simple div" do
       div = Div.new(12.to_gbs_num, 3.to_gbs_num)
       expect(div.evaluate).to eq(4.to_gbs_num)
     end
 
-    it "should evaluate to an integer division" do
+    it "evaluates to an integer division" do
       div = Div.new(10.to_gbs_num, 3.to_gbs_num)
       expect(div.evaluate).to eq(3.to_gbs_num)
     end
 
-    it "should raise an error when dividing by zero" do
+    it "raises an error when dividing by zero" do
       expect {
         Div.new(42.to_gbs_num, 0.to_gbs_num).evaluate
       }.to raise_error(GobstonesRuntimeError, 'zero division')
@@ -76,12 +76,12 @@ describe "arithmetic expressions" do
 
   describe Mod do
 
-    it "should evaluate a mod with result 0" do
+    it "evaluates a mod with result 0" do
       mod = Mod.new(4.to_gbs_num, 4.to_gbs_num)
       expect(mod.evaluate).to eq(0.to_gbs_num)
     end
 
-    it "should evaluate a mod with result > 0" do
+    it "evaluates a mod with result > 0" do
       mod = Mod.new(10.to_gbs_num, 3.to_gbs_num)
       expect(mod.evaluate).to eq(1.to_gbs_num)
     end
@@ -90,7 +90,7 @@ describe "arithmetic expressions" do
 
   describe Pow do
 
-    it "should give 1 as a result if the power is 0" do
+    it "returns 1 as a result if the power is 0" do
       pow_1 = Pow.new(1.to_gbs_num, 0.to_gbs_num)
       pow_42 = Pow.new(42.to_gbs_num, 0.to_gbs_num)
 
@@ -98,11 +98,11 @@ describe "arithmetic expressions" do
       expect(pow_42.evaluate).to eq(1.to_gbs_num)
     end
 
-    it "should calculate 2 raised to 4" do
+    it "evaluates 2 raised to 4" do
       pow = Pow.new(2.to_gbs_num, 4.to_gbs_num)
       expect(pow.evaluate).to eq(16.to_gbs_num)
     end
 
   end
 
-end
+end

data/spec/lang/expressions/boolean_expressions_spec.rb

@@ -1,56 +1,66 @@
+# TODO test/implement short-circuit?
 describe "boolean expressions" do
 
-  let(:false_value) { False.new }
-  let(:true_value) { True.new }
-
-  # TODO test/implement short-circuit?
+  let(:context) { clean_context }
 
   describe And do
 
-    it "should evaluate a simple and expression" do
-      expect(And.new(false_value, false_value).evaluate).to eq(false_value)
-      expect(And.new(false_value, true_value).evaluate).to eq(false_value)
-      expect(And.new(true_value, false_value).evaluate).to eq(false_value)
-      expect(And.new(true_value, true_value).evaluate).to eq(true_value)
+    it "evaluates a simple and expression" do
+      expect(And.new(false_value, false_value).evaluate(context)).to eq(false_value)
+      expect(And.new(false_value, true_value).evaluate(context)).to eq(false_value)
+      expect(And.new(true_value, false_value).evaluate(context)).to eq(false_value)
+      expect(And.new(true_value, true_value).evaluate(context)).to eq(true_value)
     end
 
   end
 
   describe Or do
 
-    it "should evaluate a simple or expression" do
-      expect(Or.new(false_value, false_value).evaluate).to eq(false_value)
-      expect(Or.new(false_value, true_value).evaluate).to eq(true_value)
-      expect(Or.new(true_value, false_value).evaluate).to eq(true_value)
-      expect(Or.new(true_value, true_value).evaluate).to eq(true_value)
+    it "evaluates a simple or expression" do
+      expect(Or.new(false_value, false_value).evaluate(context)).to eq(false_value)
+      expect(Or.new(false_value, true_value).evaluate(context)).to eq(true_value)
+      expect(Or.new(true_value, false_value).evaluate(context)).to eq(true_value)
+      expect(Or.new(true_value, true_value).evaluate(context)).to eq(true_value)
     end
 
   end
 
   describe Not do
 
-    it "should evaluate a simple not expression" do
-      expect(Not.new(false_value).evaluate).to eq(true_value)
-      expect(Not.new(true_value).evaluate).to eq(false_value)
+    it "evaluates a simple not expression" do
+      expect(Not.new(false_value).evaluate(context)).to eq(true_value)
+      expect(Not.new(true_value).evaluate(context)).to eq(false_value)
+    end
+
+    it "evaluates a double negated expression" do
+      expect(Not.new(Not.new(false_value)).evaluate(context)).to eq(false_value)
+      expect(Not.new(Not.new(true_value)).evaluate(context)).to eq(true_value)
     end
 
-    it "should evaluate a not not expression" do
-      expect(Not.new(Not.new(false_value)).evaluate).to eq(false_value)
-      expect(Not.new(Not.new(true_value)).evaluate).to eq(true_value)
+    it "fails if the argument is not a boolean" do
+      expect { Not.new(42.to_gbs_num).evaluate(context) }.
+          to raise_error(GobstonesTypeError, /is not a boolean/)
+      expect { Not.new(azul).evaluate(context) }.
+          to raise_error(GobstonesTypeError, /is not a boolean/)
+      expect { Not.new(oeste).evaluate(context) }.
+          to raise_error(GobstonesTypeError, /is not a boolean/)
     end
 
   end
 
   describe "nested" do
 
-    it "should evaluate and's and or's" do
-      expect(And.new(Or.new(false_value, true_value), true_value).evaluate).to eq(true_value)
+    it "evaluates and's and or's" do
+      expression = And.new Or.new(false_value, true_value), true_value
+
+      expect(expression.evaluate(context)).to eq(true_value)
     end
 
-    it "should evaluate and's, or's, and not's" do
-      expect(Not.new(Or.new(false_value, And.new(true_value, true_value))).evaluate).to eq(false_value)
+    it "evaluates and's, or's, and not's" do
+      expression = Not.new Or.new(false_value, And.new(true_value, true_value))
+      expect(expression.evaluate(context)).to eq(false_value)
     end
 
   end
 
-end
+end

data/spec/lang/expressions/comparison_expressions_spec.rb

@@ -1,18 +1,15 @@
 describe "comparison expressions" do
 
-  let(:false_value) { False.new }
-  let(:true_value) { True.new }
-
   describe Equal do
 
-    it "should evaluate same booleans as equal" do
+    it "evaluates same booleans as equal" do
       expect(Equal.new(false_value, false_value).evaluate).to eq(true_value)
       expect(Equal.new(true_value, true_value).evaluate).to eq(true_value)
       expect(Equal.new(false_value, true_value).evaluate).to eq(false_value)
       expect(Equal.new(true_value, false_value).evaluate).to eq(false_value)
     end
 
-    it "should evaluate same colors as equal" do
+    it "evaluates same colors as equal" do
       color_classes = [Azul, Negro, Rojo, Verde]
       color_classes.each do |color_class|
         expect(Equal.new(color_class.new, color_class.new).
@@ -24,7 +21,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate same directions as equal" do
+    it "evaluates same directions as equal" do
       dir_classes = [Norte, Sur, Este, Oeste]
       dir_classes.each do |dir_class|
         expect(Equal.new(dir_class.new, dir_class.new).
@@ -36,7 +33,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate same numbers as equal" do
+    it "evaluates same numbers as equal" do
       expect(Equal.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
       expect(Equal.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
     end
@@ -45,14 +42,14 @@ describe "comparison expressions" do
 
   describe NotEqual do
 
-    it "should evaluate booleans as not equal" do
+    it "evaluates booleans as not equal" do
       expect(NotEqual.new(false_value, false_value).evaluate).to eq(false_value)
       expect(NotEqual.new(true_value, true_value).evaluate).to eq(false_value)
       expect(NotEqual.new(false_value, true_value).evaluate).to eq(true_value)
       expect(NotEqual.new(true_value, false_value).evaluate).to eq(true_value)
     end
 
-    it "should evaluate same colors as equal" do
+    it "evaluates same colors as equal" do
       color_classes = [Azul, Negro, Rojo, Verde]
       color_classes.each do |color_class|
         expect(NotEqual.new(color_class.new, color_class.new).
@@ -64,7 +61,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate same directions as equal" do
+    it "evaluates same directions as equal" do
       dir_classes = [Norte, Sur, Este, Oeste]
       dir_classes.each do |dir_class|
         expect(NotEqual.new(dir_class.new, dir_class.new).
@@ -76,7 +73,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate same numbers as equal" do
+    it "evaluates same numbers as equal" do
       expect(NotEqual.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
       expect(NotEqual.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
     end
@@ -85,20 +82,20 @@ describe "comparison expressions" do
 
   describe LessThan do
 
-    it "should evaluate for booleans" do
+    it "evaluates for booleans" do
       expect(LessThan.new(false_value, false_value).evaluate).to eq(false_value)
       expect(LessThan.new(false_value, true_value).evaluate).to eq(true_value)
       expect(LessThan.new(true_value, false_value).evaluate).to eq(false_value)
       expect(LessThan.new(true_value, true_value).evaluate).to eq(false_value)
     end
 
-    it "should evaluate for numbers" do
+    it "evaluates for numbers" do
       expect(LessThan.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
       expect(LessThan.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
       expect(LessThan.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
     end
 
-    it "should evaluate for colors" do
+    it "evaluates for colors" do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
         # should not be less than itself
@@ -117,7 +114,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate for directions" do
+    it "evaluates for directions" do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
         expect(LessThan.new(dir_class.new, dir_class.new).
@@ -137,20 +134,20 @@ describe "comparison expressions" do
 
   describe LessEqual do
 
-    it "should evaluate for booleans" do
+    it "evaluates for booleans" do
       expect(LessEqual.new(false_value, false_value).evaluate).to eq(true_value)
       expect(LessEqual.new(false_value, true_value).evaluate).to eq(true_value)
       expect(LessEqual.new(true_value, false_value).evaluate).to eq(false_value)
       expect(LessEqual.new(true_value, true_value).evaluate).to eq(true_value)
     end
 
-    it "should evaluate for numbers" do
+    it "evaluates for numbers" do
       expect(LessEqual.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
       expect(LessEqual.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
       expect(LessEqual.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
     end
 
-    it "should evaluate for colors" do
+    it "evaluates for colors" do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
         expect(LessEqual.new(color_class.new, color_class.new).
@@ -166,7 +163,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate for directions" do
+    it "evaluates for directions" do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
         expect(LessEqual.new(dir_class.new, dir_class.new).
@@ -186,20 +183,20 @@ describe "comparison expressions" do
 
   describe GreaterThan do
 
-    it "should evaluate for booleans" do
+    it "evaluates for booleans" do
       expect(GreaterThan.new(false_value, false_value).evaluate).to eq(false_value)
       expect(GreaterThan.new(false_value, true_value).evaluate).to eq(false_value)
       expect(GreaterThan.new(true_value, false_value).evaluate).to eq(true_value)
       expect(GreaterThan.new(true_value, true_value).evaluate).to eq(false_value)
     end
 
-    it "should evaluate for numbers" do
+    it "evaluates for numbers" do
       expect(GreaterThan.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
       expect(GreaterThan.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
       expect(GreaterThan.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
     end
 
-    it "should evaluate for colors" do
+    it "evaluates for colors" do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
         expect(GreaterThan.new(color_class.new, color_class.new).
@@ -215,7 +212,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate for directions" do
+    it "evaluates for directions" do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
         expect(GreaterThan.new(dir_class.new, dir_class.new).
@@ -235,20 +232,20 @@ describe "comparison expressions" do
 
   describe GreaterEqual do
 
-    it "should evaluate for booleans" do
+    it "evaluates for booleans" do
       expect(GreaterEqual.new(false_value, false_value).evaluate).to eq(true_value)
       expect(GreaterEqual.new(false_value, true_value).evaluate).to eq(false_value)
       expect(GreaterEqual.new(true_value, false_value).evaluate).to eq(true_value)
       expect(GreaterEqual.new(true_value, true_value).evaluate).to eq(true_value)
     end
 
-    it "should evaluate for numbers" do
+    it "evaluates for numbers" do
       expect(GreaterEqual.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
       expect(GreaterEqual.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
       expect(GreaterEqual.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
     end
 
-    it "should evaluate for colors" do
+    it "evaluates for colors" do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
         expect(GreaterEqual.new(color_class.new, color_class.new).
@@ -264,7 +261,7 @@ describe "comparison expressions" do
       end
     end
 
-    it "should evaluate for directions" do
+    it "evaluates for directions" do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
         expect(GreaterEqual.new(dir_class.new, dir_class.new).
@@ -282,4 +279,4 @@ describe "comparison expressions" do
 
   end
 
-end
+end