gobstones 0.0.2 → 0.0.3

data/spec/lang/expressions/primitive_functions_spec.rb

@@ -1,124 +1,113 @@
-describe "primitive functions" do
-
+RSpec.describe 'evaluating primitive functions' do
   let(:context) { clean_context }
 
-  describe "nroBolitas() function" do
-
-    it "evaluates correctly in a clean context" do
+  describe 'nroBolitas() function' do
+    it 'evaluates correctly in a clean context' do
       expect(NroBolitas.new(negro).evaluate(context)).to eq(0.to_gbs_num)
     end
 
-    it "evaluates correctly in a context with some data" do
+    it 'evaluates correctly in a context with some data' do
       5.times { context.head.put negro }
+
       expect(NroBolitas.new(negro).evaluate(context)).to eq(5.to_gbs_num)
     end
-
   end
 
-  describe "hayBolitas() function" do
-
-    it "evaluates correctly in a clean context" do
+  describe 'hayBolitas() function' do
+    it 'evaluates correctly in a clean context' do
       expect(HayBolitas.new(negro).evaluate(context)).to eq(false_value)
     end
 
-    it "evaluates correctly in a context with some data" do
+    it 'evaluates correctly in a context with some data' do
       context.head.put negro
+
       expect(HayBolitas.new(negro).evaluate(context)).to eq(true_value)
     end
-
   end
 
-  describe "puedeMover() function" do
-
-    it "evaluates correctly in a clean context" do
+  describe 'puedeMover() function' do
+    it 'evaluates correctly in a clean context' do
       expect(PuedeMover.new(oeste).evaluate(context)).to eq(false_value)
     end
 
-    it "evaluates correctly in a modified context" do
+    it 'evaluates correctly in a modified context' do
       context.head.move(este)
+
       expect(PuedeMover.new(oeste).evaluate(context)).to eq(true_value)
     end
-
   end
 
-  describe "siguiente() function" do
-
-    it "evaluates correctly for numbers" do
+  describe 'siguiente() function' do
+    it 'evaluates correctly for numbers' do
       expect(Siguiente.new(15.to_gbs_num).evaluate(context)).to eq(16.to_gbs_num)
     end
 
-    it "evaluates correctly for colors" do
+    it 'evaluates correctly for colors' do
       expect(Siguiente.new(azul).evaluate(context)).to eq(negro)
       expect(Siguiente.new(negro).evaluate(context)).to eq(rojo)
       expect(Siguiente.new(rojo).evaluate(context)).to eq(verde)
       expect(Siguiente.new(verde).evaluate(context)).to eq(azul)
     end
 
-    it "evaluates correctly for directions" do
+    it 'evaluates correctly for directions' do
       expect(Siguiente.new(norte).evaluate(context)).to eq(este)
       expect(Siguiente.new(este).evaluate(context)).to eq(sur)
       expect(Siguiente.new(sur).evaluate(context)).to eq(oeste)
       expect(Siguiente.new(oeste).evaluate(context)).to eq(norte)
     end
 
-    it "evaluates correctly for booleans" do
+    it 'evaluates correctly for booleans' do
       expect(Siguiente.new(true_value).evaluate(context)).to eq(false_value)
       expect(Siguiente.new(false_value).evaluate(context)).to eq(true_value)
     end
-
   end
 
-  describe "previo() function" do
-
-    it "evaluates correctly for numbers" do
+  describe 'previo() function' do
+    it 'evaluates correctly for numbers' do
       expect(Previo.new(43.to_gbs_num).evaluate(context)).to eq(42.to_gbs_num)
     end
 
-    it "evaluates correctly for colors" do
+    it 'evaluates correctly for colors' do
       expect(Previo.new(azul).evaluate(context)).to eq(verde)
       expect(Previo.new(negro).evaluate(context)).to eq(azul)
       expect(Previo.new(rojo).evaluate(context)).to eq(negro)
       expect(Previo.new(verde).evaluate(context)).to eq(rojo)
     end
 
-    it "evaluates correctly for directions" do
+    it 'evaluates correctly for directions' do
       expect(Previo.new(norte).evaluate(context)).to eq(oeste)
       expect(Previo.new(este).evaluate(context)).to eq(norte)
       expect(Previo.new(sur).evaluate(context)).to eq(este)
       expect(Previo.new(oeste).evaluate(context)).to eq(sur)
     end
 
-    it "evaluates correctly for booleans" do
+    it 'evaluates correctly for booleans' do
       expect(Previo.new(true_value).evaluate(context)).to eq(false_value)
       expect(Previo.new(false_value).evaluate(context)).to eq(true_value)
     end
-
   end
 
-  describe "opuesto() function" do
-
-    it "evaluates correctly for numbers" do
+  describe 'opuesto() function' do
+    it 'evaluates correctly for numbers' do
       expect(Opuesto.new(23.to_gbs_num).evaluate(context)).to eq(-23.to_gbs_num)
       expect(Opuesto.new(-42.to_gbs_num).evaluate(context)).to eq(42.to_gbs_num)
     end
 
-    it "evaluates correctly for directions" do
+    it 'evaluates correctly for directions' do
       expect(Opuesto.new(norte).evaluate(context)).to eq(sur)
       expect(Opuesto.new(este).evaluate(context)).to eq(oeste)
       expect(Opuesto.new(sur).evaluate(context)).to eq(norte)
       expect(Opuesto.new(oeste).evaluate(context)).to eq(este)
     end
 
-    it "evaluates correctly for booleans" do
+    it 'evaluates correctly for booleans' do
       expect(Opuesto.new(true_value).evaluate(context)).to eq(false_value)
       expect(Opuesto.new(false_value).evaluate(context)).to eq(true_value)
     end
 
-    it "fails when evaluating for colors" do
+    it 'fails when evaluating for colors' do
       expect { Opuesto.new(verde).evaluate(context) }.
         to raise_error(GobstonesTypeError, "colors don't have opposite")
     end
-
   end
-
 end

data/spec/lang/expressions/type_bound_functions_spec.rb

@@ -1,39 +1,31 @@
-describe "type bound functions" do
-
-  describe "boolean" do
-
-    it "evaluates minBool() to False" do
+RSpec.describe 'type bound functions' do
+  describe 'for booleans' do
+    it 'evaluates minBool() to False' do
       expect(MinBool.new.evaluate).to eq(false_value)
     end
 
-    it "evaluates maxBool() to True" do
+    it 'evaluates maxBool() to True' do
       expect(MaxBool.new.evaluate).to eq(true_value)
     end
-
   end
 
-  describe "colors" do
-
-    it "evaluates minColor() to Azul" do
+  describe 'for colors' do
+    it 'evaluates minColor() to Azul' do
       expect(MinColor.new.evaluate).to eq(azul)
     end
 
-    it "evaluates maxColor() to Verde" do
+    it 'evaluates maxColor() to Verde' do
       expect(MaxColor.new.evaluate).to eq(verde)
     end
-
   end
 
-  describe "directions" do
-
-    it "evaluates minDir() to Norte" do
+  describe 'for directions' do
+    it 'evaluates minDir() to Norte' do
       expect(MinDir.new.evaluate).to eq(norte)
     end
 
-    it "evaluates maxDir() to Oeste" do
+    it 'evaluates maxDir() to Oeste' do
       expect(MaxDir.new.evaluate).to eq(oeste)
     end
-
   end
-
 end

data/spec/lang/expressions/var_name_spec.rb

@@ -1,28 +1,24 @@
-describe VarName do
-
+RSpec.describe VarName do
   let(:context) { clean_context }
   let(:variable_name) { 'var'.to_var_name }
 
-  it "returns the associated value if it was defined in the context" do
+  it 'returns the associated value if it was defined in the context' do
     context.set variable_name, 42.to_gbs_num
+
     expect(variable_name.evaluate(context)).to eq(42.to_gbs_num)
   end
 
-  it "raises an error if there is no definition in context" do
-    expect { variable_name.evaluate context }
-      .to raise_error(UndefinedVariableError)
+  it 'raises an error if there is no definition in context' do
+    expect { variable_name.evaluate context }.to raise_error(UndefinedVariableError)
   end
 
-  describe "#named?" do
-
+  describe '#named?' do
     it "is named 'var'" do
-      expect(variable_name.named? 'var').to be true
+      expect(variable_name.named?('var')).to be(true)
     end
 
     it "is not named 'blah'" do
-      expect(variable_name.named? 'blah').to be false
+      expect(variable_name.named?('blah')).to be(false)
     end
-
   end
-
 end

data/spec/lang/literals/{booleans_spec.rb → boolean_spec.rb}

@@ -1,11 +1,9 @@
-describe Boolean do
-
-  it "evaluates true to itself" do
+RSpec.describe Boolean do
+  it 'evaluates true to itself' do
     expect(true_value.evaluate).to eq(true_value)
   end
 
-  it "evaluates false to itself" do
+  it 'evaluates false to itself' do
     expect(false_value.evaluate).to eq(false_value)
   end
-
 end

data/spec/lang/literals/color_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe Color do
+  let(:all) { described_class.all.map(&:new) }
+
+  it 'includes Azul, Negro, Rojo and Verde' do
+    expect(all).to contain_exactly(azul, negro, rojo, verde)
+  end
+
+  it 'includes all color classes in the order specification' do
+    expect(described_class.all).to match_array(described_class.order)
+  end
+
+  it 'evaluates any color to itself' do
+    all.each { |color| expect(color.evaluate).to eq(color) }
+  end
+
+  it 'returns the string representation' do
+    expect(all.map(&:to_s)).to eq(%w[Azul Negro Rojo Verde])
+  end
+end

data/spec/lang/literals/direction_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Direction do
+  let(:all) { described_class.all.map(&:new) }
+
+  it 'includes Norte, Este, Sur and Oeste' do
+    expect(all.include?(norte)).to be(true)
+    expect(all.include?(este)).to be(true)
+    expect(all.include?(sur)).to be(true)
+    expect(all.include?(oeste)).to be(true)
+  end
+
+  it 'includes all direction classes in the order specification' do
+    expect(described_class.all).to match_array(described_class.order)
+  end
+
+  it 'evaluates any direction to itself' do
+    all.each { |dir| expect(dir.evaluate).to eq(dir) }
+  end
+
+  it 'returns the string representation' do
+    expect(all.map(&:to_s)).to eq(%w[Norte Sur Este Oeste])
+  end
+
+  describe Norte do
+    it 'returns Sur as the opposite direction' do
+      expect(norte.opposite).to eq(sur)
+    end
+  end
+
+  describe Este do
+    it 'returns Oeste as the opposite direction' do
+      expect(este.opposite).to eq(oeste)
+    end
+  end
+
+  describe Sur do
+    it 'returns Norte as the opposite direction' do
+      expect(sur.opposite).to eq(norte)
+    end
+  end
+
+  describe Oeste do
+    it 'returns Este as the opposite direction' do
+      expect(oeste.opposite).to eq(este)
+    end
+  end
+end

data/spec/lang/literals/{numbers_spec.rb → number_spec.rb}

@@ -1,8 +1,7 @@
-describe Number do
-
-  it "evaluates to itself" do
+RSpec.describe Number do
+  it 'evaluates to itself' do
     num = 42.to_gbs_num
+
     expect(num.evaluate).to eq(num)
   end
-
 end

data/spec/matchers/parse_matcher.rb

@@ -4,7 +4,6 @@ require 'gobstones/lang/program'
 PARSER = Gobstones::Parser::TreetopParser.new
 
 RSpec::Matchers.define :be_parsed_as do |grammar_elem|
-
   chain :and_fail do
     @expect_parser_results = false
   end
@@ -15,14 +14,14 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   match do |actual|
-    valid_nodes = [:program, :definition, :main, :expression, :command, :var_tuple]
+    valid_nodes = %i[program definition main expression command var_tuple]
     fail 'wrong expectation' if @expect_parser_results.nil?
     fail 'grammar elem not supported' unless valid_nodes.include?(grammar_elem)
 
     begin
       parse send("#{grammar_elem}_code_to_program", actual)
       @value == send("#{grammar_elem}_node_to_program", @expected)
-    rescue Gobstones::Parser::ParseError => e
+    rescue Gobstones::Parser::ParseError
       !@expect_parser_results
     end
   end
@@ -40,7 +39,7 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def main_node_to_program(node)
-    Program.new no_definitions, node
+    Program.new(no_definitions, node)
   end
 
   def definition_code_to_program(code)
@@ -48,7 +47,7 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def definition_node_to_program(node)
-    Program.new [node], Main.new(empty_body, no_return_statement)
+    Program.new([node], Main.new(empty_body, no_return_statement))
   end
 
   def expression_code_to_program(code)
@@ -56,8 +55,8 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def expression_node_to_program(node)
-    assign = SingleAssignment.new 'x'.to_var_name, node
-    main_node_to_program Main.new(CommandBlock.new([assign]), no_return_statement)
+    assign = SingleAssignment.new('x'.to_var_name, node)
+    main_node_to_program(Main.new(CommandBlock.with_just(assign), no_return_statement))
   end
 
   def command_code_to_program(code)
@@ -65,7 +64,7 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def command_node_to_program(node)
-    main_node_to_program Main.new(CommandBlock.new([node]), no_return_statement)
+    main_node_to_program(Main.new(CommandBlock.with_just(node), no_return_statement))
   end
 
   def var_tuple_code_to_program(code)
@@ -73,11 +72,10 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def var_tuple_node_to_program(node)
-    Program.new no_definitions, Main.new(empty_body, ReturnFromMain.new(node))
+    Program.new(no_definitions, Main.new(empty_body, ReturnFromMain.new(node)))
   end
 
   def parse(code)
-    @value = PARSER.parse code
+    @value = PARSER.parse(code)
   end
-
 end

data/spec/parser/arithmetic_expressions_spec.rb

@@ -1,129 +1,119 @@
-describe Gobstones::Parser, "arithmetic expressions" do
-
+RSpec.describe 'parsing arithmetic expressions' do
   let(:a) { 'a'.to_var_name }
   let(:b) { 'b'.to_var_name }
   let(:c) { 'c'.to_var_name }
   let(:d) { 'd'.to_var_name }
 
-  describe "addition and subtraction" do
-
-    it "parses a + expression" do
-      sum = Add.new a, b
+  describe 'addition and subtraction' do
+    it 'parses a + expression' do
+      sum = Add.new(a, b)
 
       expect('a+b').to be_parsed_as(:expression).and_return(sum)
       expect('a +  b').to be_parsed_as(:expression).and_return(sum)
     end
 
-    it "parses a nested + expression, associating to left" do
-      sum_ab = Add.new a, b
-      total = Add.new sum_ab, c
+    it 'parses a nested + expression, associating to left' do
+      sum_ab = Add.new(a, b)
+      total = Add.new(sum_ab, c)
 
       expect('a + b + c').to be_parsed_as(:expression).and_return(total)
     end
 
-    it "parses a - expression" do
-      sub = Sub.new a, b
+    it 'parses a - expression' do
+      sub = Sub.new(a, b)
 
       expect('a-b').to be_parsed_as(:expression).and_return(sub)
       expect('a -  b').to be_parsed_as(:expression).and_return(sub)
     end
 
-    it "parses a nested expression with + and -, associating to left" do
-      sum_ab = Add.new a, b
-      total = Sub.new sum_ab, c
+    it 'parses a nested expression with + and -, associating to left' do
+      sum_ab = Add.new(a, b)
+      total = Sub.new(sum_ab, c)
 
       expect('a + b - c').to be_parsed_as(:expression).and_return(total)
     end
-
   end
 
-  describe "multiplication, division, modulus and power" do
-
-    it "parses a * expression" do
-      mul = Mul.new a, b
+  describe 'multiplication, division, modulus and power' do
+    it 'parses a * expression' do
+      mul = Mul.new(a, b)
 
       expect('a*b').to be_parsed_as(:expression).and_return(mul)
       expect('a   * b').to be_parsed_as(:expression).and_return(mul)
     end
 
-    it "parses a nested * expression" do
-      mul_ab = Mul.new a, b
-      total = Mul.new mul_ab, c
+    it 'parses a nested * expression' do
+      mul_ab = Mul.new(a, b)
+      total = Mul.new(mul_ab, c)
 
       expect('a * b * c').to be_parsed_as(:expression).and_return(total)
     end
 
-    it "parses a div expression" do
-      div = Div.new a, b
+    it 'parses a div expression' do
+      div = Div.new(a, b)
 
       expect('a div b').to be_parsed_as(:expression).and_return(div)
       expect('a   div  b').to be_parsed_as(:expression).and_return(div)
     end
 
-    it "parses a mod expression" do
-      mod = Mod.new a, b
+    it 'parses a mod expression' do
+      mod = Mod.new(a, b)
 
       expect('a mod b').to be_parsed_as(:expression).and_return(mod)
       expect('a  mod   b').to be_parsed_as(:expression).and_return(mod)
     end
 
-    it "parses a power expression" do
-      pow = Pow.new a, b
+    it 'parses a power expression' do
+      pow = Pow.new(a, b)
 
       expect('a^b').to be_parsed_as(:expression).and_return(pow)
       expect('a ^  b').to be_parsed_as(:expression).and_return(pow)
     end
 
-    it "parses a nested power expression, associating left" do
-      pow_ab = Pow.new a, b
-      pow_abc = Pow.new pow_ab, c
-      pow_abcd = Pow.new pow_abc, d
+    it 'parses a nested power expression, associating left' do
+      pow_ab = Pow.new(a, b)
+      pow_abc = Pow.new(pow_ab, c)
+      pow_abcd = Pow.new(pow_abc, d)
 
       expect('a ^ b ^ c ^ d').to be_parsed_as(:expression).and_return(pow_abcd)
     end
-
   end
 
-  describe "complex arithmetic expressions (without parentheses)" do
-
-    it "parses using precedence of + and - over *" do
-      mul = Mul.new b, c
-      sub = Sub.new a, mul
-      add = Add.new sub, d
+  describe 'complex arithmetic expressions (without parentheses)' do
+    it 'parses using precedence of + and - over *' do
+      mul = Mul.new(b, c)
+      sub = Sub.new(a, mul)
+      add = Add.new(sub, d)
 
       expect('a - b * c + d').to be_parsed_as(:expression).and_return(add)
     end
 
-    it "parses using precedence of * over div and mod" do
-      div = Div.new a, b
-      mod = Mod.new a, c
-      inner_mul = Mul.new div, mod
-      outer_mul = Mul.new inner_mul, d
+    it 'parses using precedence of * over div and mod' do
+      div = Div.new(a, b)
+      mod = Mod.new(a, c)
+      inner_mul = Mul.new(div, mod)
+      outer_mul = Mul.new(inner_mul, d)
 
-      expect('a div b * a mod c * d').
-        to be_parsed_as(:expression).and_return(outer_mul)
+      expect('a div b * a mod c * d').to be_parsed_as(:expression).and_return(outer_mul)
     end
 
-    it "parses using precedence of div and mod over ^" do
-      pow_ab = Pow.new a, b
-      pow_cd = Pow.new c, d
-      div = Div.new pow_ab, pow_cd
+    it 'parses using precedence of div and mod over ^' do
+      pow_ab = Pow.new(a, b)
+      pow_cd = Pow.new(c, d)
+      div = Div.new(pow_ab, pow_cd)
 
       expect('a^b div c^d').to be_parsed_as(:expression).and_return(div)
     end
 
-    it "parses an expression with all kind of operators" do
-      pow = Pow.new b, c
-      mod = Mod.new a, pow
-      div = Div.new d, b
-      mul = Mul.new a, div
-      add = Add.new mod, mul
-      sub = Sub.new add, c
+    it 'parses an expression with all kind of operators' do
+      pow = Pow.new(b, c)
+      mod = Mod.new(a, pow)
+      div = Div.new(d, b)
+      mul = Mul.new(a, div)
+      add = Add.new(mod, mul)
+      sub = Sub.new(add, c)
 
-      expect('a mod b ^ c + a * d div b - c').
-        to be_parsed_as(:expression).and_return(sub)
+      expect('a mod b ^ c + a * d div b - c').to be_parsed_as(:expression).and_return(sub)
     end
-
   end
-
 end