gobstones 0.0.1.1 → 0.0.2

data/spec/lang/expressions/enclosed_by_parens_expression_spec.rb

@@ -0,0 +1,11 @@
+describe EnclosedByParensExpression do
+
+  let(:context) { clean_context }
+
+  it "evaluates the inner expression" do
+    expression = EnclosedByParensExpression.new rojo
+
+    expect(expression.evaluate(context)).to eq(rojo)
+  end
+
+end

data/spec/lang/expressions/function_call_spec.rb

@@ -0,0 +1,29 @@
+describe FunctionCall do
+
+  it "evaluates an existing function and returns its result when calling it" do
+    return_statement = ReturnFromFunction.new [42.to_gbs_num]
+    my_function = Function.new 'myFunction', no_arguments, empty_body, return_statement
+    program = Program.new [my_function], no_return_statement
+    context = program_context_for program
+    call = FunctionCall.new 'myFunction', []
+
+    result = call.evaluate context
+
+    expect(result).to eq(42.to_gbs_num)
+  end
+
+  it "evaluates an existing function with some arguments" do
+    number_a, number_b, number_c = 'a'.to_var_name, 'b'.to_var_name, 'c'.to_var_name
+    return_statement = ReturnFromFunction.new [Add.new(Add.new(number_a, number_b), number_c)]
+    args = VarTuple.new [number_a, number_b, number_c]
+    my_function = Function.new 'myFunction', args, empty_body, return_statement
+    program = Program.new [my_function], no_return_statement
+    context = program_context_for program
+    call = FunctionCall.new 'myFunction', [1.to_gbs_num, 2.to_gbs_num, 3.to_gbs_num]
+
+    result = call.evaluate context
+
+    expect(result).to eq(6.to_gbs_num)
+  end
+
+end

data/spec/lang/expressions/primitive_functions_spec.rb

@@ -1,126 +1,124 @@
 describe "primitive functions" do
 
-  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
-  let(:black) { Negro.new }
-  let(:west) { Oeste.new }
+  let(:context) { clean_context }
 
   describe "nroBolitas() function" do
 
-    it "should evaluates correctly in a clean context" do
-      expect(NroBolitas.new(black).evaluate(context)).to eq(0.to_gbs_num)
+    it "evaluates correctly in a clean context" do
+      expect(NroBolitas.new(negro).evaluate(context)).to eq(0.to_gbs_num)
     end
 
-    it "should evaluate correctly in a context with some data" do
-      5.times { context.head.put black }
-      expect(NroBolitas.new(black).evaluate(context)).to eq(5.to_gbs_num)
+    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 "should evaluate correctly in a clean context" do
-      expect(HayBolitas.new(black).evaluate(context)).to eq(false.to_gbs_bool)
+    it "evaluates correctly in a clean context" do
+      expect(HayBolitas.new(negro).evaluate(context)).to eq(false_value)
     end
 
-    it "should evaluate correctly in a context with some data" do
-      context.head.put black
-      expect(HayBolitas.new(black).evaluate(context)).to eq(true.to_gbs_bool)
+    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 "should evaluate correctly in a clean context" do
-      expect(PuedeMover.new(west).evaluate(context)).to eq(false.to_gbs_bool)
+    it "evaluates correctly in a clean context" do
+      expect(PuedeMover.new(oeste).evaluate(context)).to eq(false_value)
     end
 
-    it "should evaluate correctly in a modified context" do
-      context.head.move(Este.new)
-      expect(PuedeMover.new(west).evaluate(context)).to eq(true.to_gbs_bool)
+    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 "should evaluate correctly for numbers" do
-      expect(Siguiente.new(15.to_gbs_num).evaluate).to eq(16.to_gbs_num)
+    it "evaluates correctly for numbers" do
+      expect(Siguiente.new(15.to_gbs_num).evaluate(context)).to eq(16.to_gbs_num)
     end
 
-    it "should evaluate correctly for colors" do
-      expect(Siguiente.new(Azul.new).evaluate).to eq(Negro.new)
-      expect(Siguiente.new(Negro.new).evaluate).to eq(Rojo.new)
-      expect(Siguiente.new(Rojo.new).evaluate).to eq(Verde.new)
-      expect(Siguiente.new(Verde.new).evaluate).to eq(Azul.new)
+    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 "should evaluate correctly for directions" do
-      expect(Siguiente.new(Norte.new).evaluate).to eq(Este.new)
-      expect(Siguiente.new(Este.new).evaluate).to eq(Sur.new)
-      expect(Siguiente.new(Sur.new).evaluate).to eq(Oeste.new)
-      expect(Siguiente.new(Oeste.new).evaluate).to eq(Norte.new)
+    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 "should evaluate correctly for booleans" do
-      expect(Siguiente.new(True.new).evaluate).to eq(False.new)
-      expect(Siguiente.new(False.new).evaluate).to eq(True.new)
+    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 "should evaluate correctly for numbers" do
-      expect(Previo.new(43.to_gbs_num).evaluate).to eq(42.to_gbs_num)
+    it "evaluates correctly for numbers" do
+      expect(Previo.new(43.to_gbs_num).evaluate(context)).to eq(42.to_gbs_num)
     end
 
-    it "should evaluate correctly for colors" do
-      expect(Previo.new(Azul.new).evaluate).to eq(Verde.new)
-      expect(Previo.new(Negro.new).evaluate).to eq(Azul.new)
-      expect(Previo.new(Rojo.new).evaluate).to eq(Negro.new)
-      expect(Previo.new(Verde.new).evaluate).to eq(Rojo.new)
+    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 "should evaluate correctly for directions" do
-      expect(Previo.new(Norte.new).evaluate).to eq(Oeste.new)
-      expect(Previo.new(Este.new).evaluate).to eq(Norte.new)
-      expect(Previo.new(Sur.new).evaluate).to eq(Este.new)
-      expect(Previo.new(Oeste.new).evaluate).to eq(Sur.new)
+    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 "should evaluate correctly for booleans" do
-      expect(Previo.new(True.new).evaluate).to eq(False.new)
-      expect(Previo.new(False.new).evaluate).to eq(True.new)
+    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 "should evaluate correctly for numbers" do
-      expect(Opuesto.new(23.to_gbs_num).evaluate).to eq(-23.to_gbs_num)
-      expect(Opuesto.new(-42.to_gbs_num).evaluate).to eq(42.to_gbs_num)
+    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 "should evaluate correctly for directions" do
-      expect(Opuesto.new(Norte.new).evaluate).to eq(Sur.new)
-      expect(Opuesto.new(Este.new).evaluate).to eq(Oeste.new)
-      expect(Opuesto.new(Sur.new).evaluate).to eq(Norte.new)
-      expect(Opuesto.new(Oeste.new).evaluate).to eq(Este.new)
+    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 "should evaluate correctly for booleans" do
-      expect(Opuesto.new(True.new).evaluate).to eq(False.new)
-      expect(Opuesto.new(False.new).evaluate).to eq(True.new)
+    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 "should fail when evaluating for colors" do
-      expect { Opuesto.new(Verde.new).evaluate }.
+    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
+end

data/spec/lang/expressions/type_bound_functions_spec.rb

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

data/spec/lang/expressions/var_name_spec.rb

@@ -1,16 +1,28 @@
 describe VarName do
 
-  let(:context) { ExecutionContext.new }
-  let(:var_name) { VarName.new 'var' }
+  let(:context) { clean_context }
+  let(:variable_name) { 'var'.to_var_name }
 
-  it "should return the associated value if it was defined in the context" do
-    context.set var_name, 42.to_gbs_num
-    expect(var_name.evaluate(context)).to eq(42.to_gbs_num)
+  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 "should raise an error if there is no definition in context" do
-    expect { var_name.evaluate context }
+  it "raises an error if there is no definition in context" do
+    expect { variable_name.evaluate context }
       .to raise_error(UndefinedVariableError)
   end
 
-end
+  describe "#named?" do
+
+    it "is named 'var'" do
+      expect(variable_name.named? 'var').to be true
+    end
+
+    it "is not named 'blah'" do
+      expect(variable_name.named? 'blah').to be false
+    end
+
+  end
+
+end

data/spec/lang/literals/booleans_spec.rb

@@ -1,13 +1,11 @@
 describe Boolean do
 
-  it "should evaluate true to self" do
-    bool = True.new
-    expect(bool.evaluate).to eq(bool)
+  it "evaluates true to itself" do
+    expect(true_value.evaluate).to eq(true_value)
   end
 
-  it "should evaluate false to self" do
-    bool = False.new
-    expect(bool.evaluate).to eq(bool)
+  it "evaluates false to itself" do
+    expect(false_value.evaluate).to eq(false_value)
   end
 
-end
+end

data/spec/lang/literals/colors_spec.rb

@@ -1,13 +1,13 @@
 describe "colors" do
 
-  let(:all) { [Azul.new, Negro.new, Rojo.new, Verde.new] }
+  let(:all) { [azul, negro, rojo, verde] }
 
-  it "should evaluate any color to self" do
+  it "evaluates any color to itself" do
     all.each { |color| expect(color.evaluate).to eq(color) }
   end
 
-  it "should give the string representation" do
+  it "returns the string representation" do
     expect(all.map(&:to_s)).to eq(['Azul', 'Negro', 'Rojo', 'Verde'])
   end
 
-end
+end

data/spec/lang/literals/directions_spec.rb

@@ -1,45 +1,45 @@
 describe "directions" do
 
-  let(:all) { [Norte.new, Sur.new, Este.new, Oeste.new] }
+  let(:all) { [norte, sur, este, oeste] }
 
-  it "should evaluate any direction to self" do
+  it "evaluates any direction to itself" do
     all.each { |dir| expect(dir.evaluate).to eq(dir) }
   end
 
-  it "should return the string representation" do
+  it "returns the string representation" do
     expect(all.map(&:to_s)).to eq(['Norte', 'Sur', 'Este', 'Oeste'])
   end
 
   describe Norte do
 
-    it "should return Sur as opposite direction" do
-      expect(Norte.new.opposite).to eq(Sur.new)
+    it "returns Sur as the opposite direction" do
+      expect(norte.opposite).to eq(sur)
     end
 
   end
 
   describe Este do
 
-    it "should return Oeste as opposite direction" do
-      expect(Este.new.opposite).to eq(Oeste.new)
+    it "returns Oeste as the opposite direction" do
+      expect(este.opposite).to eq(oeste)
     end
 
   end
 
   describe Sur do
 
-    it "should return Norte as opposite direction" do
-      expect(Sur.new.opposite).to eq(Norte.new)
+    it "returns Norte as the opposite direction" do
+      expect(sur.opposite).to eq(norte)
     end
 
   end
 
   describe Oeste do
 
-    it "should return Este as opposite direction" do
-      expect(Oeste.new.opposite).to eq(Este.new)
+    it "returns Este as the opposite direction" do
+      expect(oeste.opposite).to eq(este)
     end
 
   end
 
-end
+end

data/spec/lang/literals/numbers_spec.rb

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

data/spec/matchers/parse_matcher.rb

@@ -5,8 +5,6 @@ PARSER = Gobstones::Parser::TreetopParser.new
 
 RSpec::Matchers.define :be_parsed_as do |grammar_elem|
 
-  @valid_nodes = [:program, :definition, :main, :expression, :command, :var_tuple ]
-
   chain :and_fail do
     @expect_parser_results = false
   end
@@ -17,8 +15,9 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   match do |actual|
+    valid_nodes = [:program, :definition, :main, :expression, :command, :var_tuple]
     fail 'wrong expectation' if @expect_parser_results.nil?
-    fail 'grammar elem not supported' if !@valid_nodes.include?(grammar_elem)
+    fail 'grammar elem not supported' unless valid_nodes.include?(grammar_elem)
 
     begin
       parse send("#{grammar_elem}_code_to_program", actual)
@@ -41,7 +40,7 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def main_node_to_program(node)
-    Program.new [], node
+    Program.new no_definitions, node
   end
 
   def definition_code_to_program(code)
@@ -49,7 +48,7 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def definition_node_to_program(node)
-    Program.new [node], Main.new(CmdBlock.new([]), NoReturnStatement.new)
+    Program.new [node], Main.new(empty_body, no_return_statement)
   end
 
   def expression_code_to_program(code)
@@ -57,8 +56,8 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def expression_node_to_program(node)
-    assign = SingleAssignment.new VarName.new('x'), node
-    main_node_to_program Main.new(CmdBlock.new([assign]), NoReturnStatement.new)
+    assign = SingleAssignment.new 'x'.to_var_name, node
+    main_node_to_program Main.new(CommandBlock.new([assign]), no_return_statement)
   end
 
   def command_code_to_program(code)
@@ -66,7 +65,7 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def command_node_to_program(node)
-    main_node_to_program Main.new(CmdBlock.new([node]), NoReturnStatement.new)
+    main_node_to_program Main.new(CommandBlock.new([node]), no_return_statement)
   end
 
   def var_tuple_code_to_program(code)
@@ -74,11 +73,11 @@ RSpec::Matchers.define :be_parsed_as do |grammar_elem|
   end
 
   def var_tuple_node_to_program(node)
-    Program.new [], Main.new(CmdBlock.new([]), ReturnFromMain.new(node))
+    Program.new no_definitions, Main.new(empty_body, ReturnFromMain.new(node))
   end
 
   def parse(code)
     @value = PARSER.parse code
   end
 
-end
+end