gobstones 0.0.1.1

data/spec/lang/expressions/primitive_functions_spec.rb

@@ -0,0 +1,126 @@
+describe "primitive functions" do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:black) { Negro.new }
+  let(:west) { Oeste.new }
+
+  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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    end
+
+    it "should fail when evaluating for colors" do
+      expect { Opuesto.new(Verde.new).evaluate }.
+        to raise_error(GobstonesTypeError, "colors don't have opposite")
+    end
+
+  end
+
+end

data/spec/lang/expressions/type_bound_functions_spec.rb

@@ -0,0 +1,39 @@
+describe "type bound functions" do
+
+  describe "boolean" do
+
+    it "should evaluate minBool() to False" do
+      expect(MinBool.new.evaluate).to eq(False.new)
+    end
+
+    it "should evaluate maxBool() to True" do
+      expect(MaxBool.new.evaluate).to eq(True.new)
+    end
+
+  end
+
+  describe "colors" do
+
+    it "should evaluate minColor() to Azul" do
+      expect(MinColor.new.evaluate).to eq(Azul.new)
+    end
+
+    it "should evaluate maxColor() to Verde" do
+      expect(MaxColor.new.evaluate).to eq(Verde.new)
+    end
+
+  end
+
+  describe "directions" do
+
+    it "should evaluate minDir() to Norte" do
+      expect(MinDir.new.evaluate).to eq(Norte.new)
+    end
+
+    it "should evaluate maxDir() to Oeste" do
+      expect(MaxDir.new.evaluate).to eq(Oeste.new)
+    end
+
+  end
+
+end

data/spec/lang/expressions/var_name_spec.rb

@@ -0,0 +1,16 @@
+describe VarName do
+
+  let(:context) { ExecutionContext.new }
+  let(:var_name) { VarName.new 'var' }
+
+  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)
+  end
+
+  it "should raise an error if there is no definition in context" do
+    expect { var_name.evaluate context }
+      .to raise_error(UndefinedVariableError)
+  end
+
+end

data/spec/lang/literals/booleans_spec.rb

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

data/spec/lang/literals/colors_spec.rb

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

data/spec/lang/literals/directions_spec.rb

@@ -0,0 +1,45 @@
+describe "directions" do
+
+  let(:all) { [Norte.new, Sur.new, Este.new, Oeste.new] }
+
+  it "should evaluate any direction to self" do
+    all.each { |dir| expect(dir.evaluate).to eq(dir) }
+  end
+
+  it "should return 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)
+    end
+
+  end
+
+  describe Este do
+
+    it "should return Oeste as opposite direction" do
+      expect(Este.new.opposite).to eq(Oeste.new)
+    end
+
+  end
+
+  describe Sur do
+
+    it "should return Norte as opposite direction" do
+      expect(Sur.new.opposite).to eq(Norte.new)
+    end
+
+  end
+
+  describe Oeste do
+
+    it "should return Este as opposite direction" do
+      expect(Oeste.new.opposite).to eq(Este.new)
+    end
+
+  end
+
+end

data/spec/lang/literals/numbers_spec.rb

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

data/spec/matchers/parse_matcher.rb

@@ -0,0 +1,84 @@
+require 'gobstones/parser/treetop_parser'
+require 'gobstones/lang/program'
+
+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
+
+  chain :and_return do |expected|
+    @expect_parser_results = true
+    @expected = expected
+  end
+
+  match do |actual|
+    fail 'wrong expectation' if @expect_parser_results.nil?
+    fail 'grammar elem not supported' if !@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
+      !@expect_parser_results
+    end
+  end
+
+  def program_code_to_program(code)
+    code
+  end
+
+  def program_node_to_program(node)
+    node
+  end
+
+  def main_code_to_program(code)
+    code
+  end
+
+  def main_node_to_program(node)
+    Program.new [], node
+  end
+
+  def definition_code_to_program(code)
+    "#{code}\nprocedure Main() {}"
+  end
+
+  def definition_node_to_program(node)
+    Program.new [node], Main.new(CmdBlock.new([]), NoReturnStatement.new)
+  end
+
+  def expression_code_to_program(code)
+    "procedure Main() { x := #{code} }"
+  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)
+  end
+
+  def command_code_to_program(code)
+    "procedure Main() { #{code} }"
+  end
+
+  def command_node_to_program(node)
+    main_node_to_program Main.new(CmdBlock.new([node]), NoReturnStatement.new)
+  end
+
+  def var_tuple_code_to_program(code)
+    "procedure Main() { return #{code} }"
+  end
+
+  def var_tuple_node_to_program(node)
+    Program.new [], Main.new(CmdBlock.new([]), ReturnFromMain.new(node))
+  end
+
+  def parse(code)
+    @value = PARSER.parse code
+  end
+
+end

data/spec/parser/arithmetic_expressions_spec.rb

@@ -0,0 +1,129 @@
+describe Gobstones::Parser, "arithmetic expressions" do
+
+  let(:a) { VarName.new 'a' }
+  let(:b) { VarName.new 'b' }
+  let(:c) { VarName.new 'c' }
+  let(:d) { VarName.new 'd' }
+
+  describe "addition and subtraction" do
+
+    it "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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 "should parse 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)
+    end
+
+    it "should parse 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 "should parse 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)
+    end
+
+  end
+
+end