gobstones 0.0.2 → 0.0.3

data/spec/lang/commands/repeat_with_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe RepeatWith do
+  let(:context) { clean_context }
+  let(:var_name) { 'var'.to_var_name }
+
+  it 'iterates over numbers when evaluating' do
+    command_block = CommandBlock.with_just(Poner.new(rojo))
+    repeat_with = described_class.new(var_name, 1.to_gbs_num, 10.to_gbs_num, command_block)
+
+    repeat_with.evaluate context
+
+    expect(context.head.number_of_balls(rojo)).to eq(10)
+  end
+
+  it 'raises an error if the range values have not the same type' do
+    repeat_with = described_class.new(var_name, 1.to_gbs_num, este, empty_body)
+
+    expect { repeat_with.evaluate context }.
+      to raise_error(GobstonesTypeError, /types don't match in range values/)
+  end
+
+  it 'raises an error if the index variable is previously defined' do
+    repeat_with = described_class.new(var_name, 1.to_gbs_num, 5.to_gbs_num, empty_body)
+
+    context.set var_name, 42.to_gbs_num
+
+    expect { repeat_with.evaluate context }.
+      to raise_error(GobstonesRuntimeError, /index variable can't be used because it's already defined/)
+  end
+
+  it 'removes the index variable assignment after execution' do
+    repeat_with = described_class.new(var_name, azul, verde, empty_body)
+
+    repeat_with.evaluate context
+
+    expect(context.has_variable_named?('var')).to be(false)
+  end
+
+  it 'allows to use the index variable inside the command block' do
+    cmd_block = CommandBlock.with_just(Poner.new(var_name))
+    repeat_with = described_class.new(var_name, azul, verde, cmd_block)
+
+    repeat_with.evaluate context
+
+    expect_balls(azul, negro, rojo, verde)
+  end
+
+  it 'does exactly one iteration if range values are the same' do
+    cmd_block = CommandBlock.with_just(Poner.new(verde))
+    repeat_with = described_class.new(var_name, 1.to_gbs_num, 1.to_gbs_num, cmd_block)
+
+    repeat_with.evaluate context
+
+    expect_balls(verde)
+  end
+
+  it 'does no iterations if the from is higher than the to' do
+    cmd_block = CommandBlock.with_just(Poner.new(verde))
+    repeat_with = described_class.new(var_name, 8.to_gbs_num, 4.to_gbs_num, cmd_block)
+
+    repeat_with.evaluate context
+
+    expect_no_balls(verde)
+  end
+end

data/spec/lang/commands/sacar_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Sacar do
+  let(:context) { clean_context }
+
+  it 'takes off balls from the board when evaluating' do
+    3.times { context.head.put rojo }
+
+    described_class.new(rojo).evaluate context
+
+    expect(context.head.number_of_balls(rojo)).to eq(2)
+  end
+
+  it 'undoes a command' do
+    described_class.new(rojo).undo context
+
+    expect(context.head.number_of_balls(rojo)).to eq(1)
+  end
+
+  it 'returns the opposite command' do
+    opposite_command = described_class.new(rojo).opposite
+
+    expect(opposite_command).to eq(Poner.new(rojo))
+  end
+
+  it 'fails if there are no balls in the board' do
+    expect { described_class.new(rojo).evaluate(context) }.to raise_error(EmptyCellError)
+  end
+
+  it 'fails if the argument is not a color' do
+    expect { described_class.new(true_value).evaluate(context) }.
+      to raise_error(GobstonesTypeError, /is not a color/)
+  end
+end

data/spec/lang/commands/single_assignment_spec.rb

@@ -1,13 +1,12 @@
-describe SingleAssignment do
-
+RSpec.describe SingleAssignment do
   let(:context) { clean_context }
   let(:a) { 'a'.to_var_name }
 
-  it "evaluates the associated expression to the var name" do
-    assign = SingleAssignment.new a, Add.new(3.to_gbs_num, 4.to_gbs_num)
+  it 'evaluates the associated expression to the var name' do
+    assign = described_class.new(a, Add.new(3.to_gbs_num, 4.to_gbs_num))
     assign.evaluate context
-    expect(context.has_variable_named?('a')).to be true
+
+    expect(context.has_variable_named?('a')).to be(true)
     expect(context.get(a)).to eq(7.to_gbs_num)
   end
-
 end

data/spec/lang/commands/skip_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe Skip do
+  let(:context) { clean_context }
+
+  it 'evaluates and does nothing' do
+    described_class.new.evaluate(context)
+
+    expect_positioned_at(0, 0)
+    expect(context.head.board).to be_empty
+  end
+end

data/spec/lang/commands/vaciar_tablero_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe VaciarTablero do
+  let(:context) { clean_context }
+
+  it 'empties the board in the context' do
+    context.head.put(rojo)
+    described_class.new.evaluate(context)
+
+    expect(context.board).to be_empty
+  end
+end

data/spec/lang/commands/while_spec.rb

@@ -0,0 +1,39 @@
+RSpec.describe While do
+  let(:context) { clean_context }
+  let(:while_block) { CommandBlock.with_just(Poner.new(verde)) }
+
+  def stub_condition(times)
+    instance_double(Boolean).tap do |condition|
+      expected_values = [true_value] * times + [false_value]
+      allow(condition).to receive(:evaluate).and_return(*expected_values)
+    end
+  end
+
+  it 'evaluates the command block until the condition is not satisfied' do
+    while_cmd = described_class.new(stub_condition(3), while_block)
+
+    while_cmd.evaluate context
+
+    expect(context.head.number_of_balls(verde)).to eq(3)
+  end
+
+  it 'does not evaluate the command block if the condition is false' do
+    while_cmd = described_class.new(stub_condition(0), while_block)
+
+    while_cmd.evaluate context
+
+    expect_no_balls(verde)
+  end
+
+  it 'fails with type error if the condition is not boolean' do
+    while_cmd = described_class.new(sur, while_block)
+
+    expect { while_cmd.evaluate context }.to raise_error(GobstonesTypeError, /is not a boolean/)
+  end
+
+  it 'fails with stack overflow if the condition is always true' do
+    while_cmd = described_class.new(true_value, while_block)
+
+    expect { while_cmd.evaluate context }.to raise_error(GobstonesRuntimeError, /stack overflow/)
+  end
+end

data/spec/lang/definitions/main_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe Main do
+  subject(:if_evaluation) { main.evaluate(context) }
+
+  let(:context) { clean_context }
+  let(:return_tuple) { VarTuple.with_names(%w[x y]) }
+  let(:return_from_main) { ReturnFromMain.new(return_tuple) }
+  let(:assign_x) { SingleAssignment.new('x'.to_var_name, 42.to_gbs_num) }
+  let(:assign_y) { SingleAssignment.new('y'.to_var_name, verde) }
+  let(:command_block) { CommandBlock.new([assign_x, assign_y]) }
+  let(:main) { described_class.new(command_block, return_from_main) }
+
+  it 'evaluates the body' do
+    if_evaluation
+
+    %w[x y].each { |var_name| expect(context).to have_variable_named(var_name) }
+  end
+
+  context 'with return statement' do
+    it 'returns its return value, if there is one' do
+      expect(if_evaluation).to eq(
+        'x'.to_var_name => 42.to_gbs_num,
+        'y'.to_var_name => verde,
+      )
+    end
+  end
+
+  context 'without return statement' do
+    let(:return_from_main) { no_return_statement }
+
+    it 'returns an empty result when no return statement is present' do
+      expect(if_evaluation).to be_empty
+    end
+  end
+end

data/spec/lang/definitions/no_return_statement_spec.rb

@@ -1,10 +1,9 @@
-describe NoReturnStatement do
+RSpec.describe NoReturnStatement do
+  subject(:no_return_statement) { described_class.new }
 
   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 }
+  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

@@ -1,16 +1,13 @@
-describe VarTuple do
+RSpec.describe VarTuple do
+  let(:var_tuple) { described_class.with_names(%w[a b c]) }
 
-  let (:var_tuple) { VarTuple.new ['a'.to_var_name, 'b'.to_var_name, 'c'.to_var_name] }
-
-  it "returns its length" do
+  it 'returns its length' do
     expect(var_tuple.length).to eq(3)
   end
 
-  it "returns a variable at a given index" do
+  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

@@ -1,108 +1,81 @@
-describe "arithmetic expressions" do
-
+RSpec.describe 'arithmetic expressions' do
   describe Add 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)
+    it 'evaluates with two numbers' do
+      expect(described_class.numbers(42, 23).evaluate).to eq(65.to_gbs_num)
     end
 
-    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
-      add_43_23 = Add.new add_27_16, 23.to_gbs_num
-      add_66_42 = Add.new add_43_23, 42.to_gbs_num
+    it 'evaluates nested add expressions' do
+      add_4_8 = described_class.numbers(4, 8)
+      add_12_15 = described_class.new(add_4_8, 15.to_gbs_num)
+      add_27_16 = described_class.new(add_12_15, 16.to_gbs_num)
+      add_43_23 = described_class.new(add_27_16, 23.to_gbs_num)
+      add_66_42 = described_class.new(add_43_23, 42.to_gbs_num)
 
       expect(add_66_42.evaluate).to eq(108.to_gbs_num)
     end
-
   end
 
   describe Sub 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)
+    it 'evaluates with two numbers' do
+      expect(described_class.numbers(42, 15).evaluate).to eq(27.to_gbs_num)
     end
 
-    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)
+    it 'evaluates returning a negative result' do
+      expect(described_class.numbers(15, 42).evaluate).to eq(-27.to_gbs_num)
     end
 
-    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
+    it 'evaluates nested sub expressions' do
+      sub_n1_n2 = described_class.numbers(42, 15)
+      sub = described_class.new(sub_n1_n2, 8.to_gbs_num)
 
       expect(sub.evaluate).to eq(19.to_gbs_num)
     end
-
   end
 
   describe 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)
+    it 'evaluates a simple mul' do
+      expect(described_class.numbers(4, 8).evaluate).to eq(32.to_gbs_num)
     end
 
-    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
+    it 'evaluates a nested mul expression' do
+      mul = described_class.numbers(-2, 4)
 
+      expect(described_class.new(mul, 5.to_gbs_num).evaluate).to eq(-40.to_gbs_num)
+    end
   end
 
   describe 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)
+    it 'evaluates a simple div' do
+      expect(described_class.numbers(12, 3).evaluate).to eq(4.to_gbs_num)
     end
 
-    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)
+    it 'evaluates to an integer division' do
+      expect(described_class.numbers(10, 3).evaluate).to eq(3.to_gbs_num)
     end
 
-    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')
+    it 'raises an error when dividing by zero' do
+      expect { described_class.numbers(42, 0).evaluate }.to raise_error(GobstonesRuntimeError, 'zero division')
     end
-
   end
 
   describe Mod 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)
+    it 'evaluates a mod with result 0' do
+      expect(described_class.numbers(4, 4).evaluate).to eq(0.to_gbs_num)
     end
 
-    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)
+    it 'evaluates a mod with result > 0' do
+      expect(described_class.numbers(10, 3).evaluate).to eq(1.to_gbs_num)
     end
-
   end
 
   describe Pow 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)
-
-      expect(pow_1.evaluate).to eq(1.to_gbs_num)
-      expect(pow_42.evaluate).to eq(1.to_gbs_num)
+    it 'returns 1 as a result if the power is 0' do
+      expect(described_class.numbers(1, 0).evaluate).to eq(1.to_gbs_num)
+      expect(described_class.numbers(42, 0).evaluate).to eq(1.to_gbs_num)
     end
 
-    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)
+    it 'evaluates 2 raised to 4' do
+      expect(described_class.numbers(2, 4).evaluate).to eq(16.to_gbs_num)
     end
-
   end
-
 end

data/spec/lang/expressions/boolean_expressions_spec.rb

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