gobstones 0.0.2 → 0.0.3

data/lib/gobstones/lang/literals/{colors.rb → color.rb}

@@ -2,10 +2,11 @@ require 'gobstones/lang/literals/literal'
 require 'gobstones/runner/errors/gobstones_type_error'
 
 module Gobstones
-
   module Lang
-
     class Color < Literal
+      def self.all
+        [Azul, Negro, Rojo, Verde]
+      end
 
       def self.order
         [Azul, Negro, Rojo, Verde]
@@ -16,17 +17,15 @@ module Gobstones
       end
 
       def opposite
-        raise Gobstones::Runner::GobstonesTypeError, "colors don't have opposite"
+        raise Runner::GobstonesTypeError, "colors don't have opposite"
       end
 
       def return_type
         :Color
       end
-
     end
 
     class Azul < Color
-
       def previous
         Verde.new
       end
@@ -38,11 +37,9 @@ module Gobstones
       def to_s
         'Azul'
       end
-
     end
 
     class Negro < Color
-
       def previous
         Azul.new
       end
@@ -54,11 +51,9 @@ module Gobstones
       def to_s
         'Negro'
       end
-
     end
 
     class Rojo < Color
-
       def previous
         Negro.new
       end
@@ -70,11 +65,9 @@ module Gobstones
       def to_s
         'Rojo'
       end
-
     end
 
     class Verde < Color
-
       def previous
         Rojo.new
       end
@@ -86,9 +79,6 @@ module Gobstones
       def to_s
         'Verde'
       end
-
     end
-
   end
-
 end

data/lib/gobstones/lang/literals/{directions.rb → direction.rb}

@@ -1,10 +1,11 @@
 require 'gobstones/lang/literals/literal'
 
 module Gobstones
-
   module Lang
-
     class Direction < Literal
+      def self.all
+        [Norte, Sur, Este, Oeste]
+      end
 
       def self.order
         [Norte, Este, Sur, Oeste]
@@ -17,11 +18,9 @@ module Gobstones
       def return_type
         :Direction
       end
-
     end
 
     class Norte < Direction
-
       def can_move?(head)
         head.can_move_north?
       end
@@ -45,11 +44,9 @@ module Gobstones
       def to_s
         'Norte'
       end
-
     end
 
     class Este < Direction
-
       def can_move?(head)
         head.can_move_east?
       end
@@ -73,11 +70,9 @@ module Gobstones
       def to_s
         'Este'
       end
-
     end
 
     class Sur < Direction
-
       def can_move?(head)
         head.can_move_south?
       end
@@ -101,11 +96,9 @@ module Gobstones
       def to_s
         'Sur'
       end
-
     end
 
     class Oeste < Direction
-
       def can_move?(head)
         head.can_move_west?
       end
@@ -129,9 +122,6 @@ module Gobstones
       def to_s
         'Oeste'
       end
-
     end
-
   end
-
 end

data/lib/gobstones/lang/literals/literal.rb

@@ -1,58 +1,69 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/lang/expressions/expression'
 require 'gobstones/runner/errors/gobstones_type_error'
+require 'gobstones/runner/execution_context'
+require 'gobstones/extensions/boolean'
+require 'error_handling_protocol'
 
 module Gobstones
-
   module Lang
-
-    class Literal
-
+    class Literal < Expression
       include Comparable
-      include Gobstones::EqualByClass
 
-      def evaluate(context=nil)
+      def evaluate(_context = Runner::NullExecutionContext.new)
         self
       end
 
+      # TODO EqualityDefinition module seems to fail used with Comparable
+
+      def ==(other)
+        self.class == other.class
+      end
+
+      alias_method :eql?, :==
+
       def <=>(other)
-        self == other ? 0 : (self < other ? -1 : 1)
+        return 0 if self == other
+        return -1 if self < other
+
+        1
       end
 
-      def <(other)
-        raise 'subclass responsibility'
+      def <(_other)
+        subclass_responsibility
       end
 
       OPERATORS_MAPPING = {
-          :equal => :==,
-          :not_equal => '!='.to_sym,
-          :less_than => :<,
-          :less_equal => :<=,
-          :greater_than => :>, :greater_equal => :>=
-      }
+        equal: :==,
+        not_equal: '!='.to_sym,
+        less_than: :<,
+        less_equal: :<=,
+        greater_than: :>,
+        greater_equal: :>=,
+      }.freeze
 
       OPERATORS_MAPPING.each do |gbs_op, ruby_op|
-        define_method gbs_op do |other|
-          send(ruby_op, other) ? True.new : False.new
+        define_method(gbs_op) do |other|
+          send(ruby_op, other).to_gbs_bool
         end
       end
 
       def same_type_as(other)
-        self.return_type == other.return_type
+        return_type == other.return_type
       end
 
       def return_type
-        raise 'subclass responsibility'
+        subclass_responsibility
       end
 
-      def if_true(block, context)
+      def if_true(_block, _context)
         not_boolean_type_error
       end
 
-      def if_false(block, context)
+      def if_false(_block, _context)
         not_boolean_type_error
       end
 
-      def is_true?
+      def true?
         not_boolean_type_error
       end
 
@@ -63,11 +74,8 @@ module Gobstones
       private
 
       def not_boolean_type_error
-        raise Gobstones::Runner::GobstonesTypeError, "#{self} is not a boolean"
+        raise Runner::GobstonesTypeError, "#{self} is not a boolean"
       end
-
     end
-
   end
-
 end

data/lib/gobstones/lang/literals/number.rb

@@ -1,18 +1,15 @@
 require 'gobstones/lang/literals/literal'
 
 module Gobstones
-
   module Lang
-
     class Number < Literal
-
       attr_reader :value
 
       def initialize(num)
         @value = num
       end
 
-      def == other
+      def ==(other)
         super(other) && value == other.value
       end
 
@@ -24,9 +21,9 @@ module Gobstones
         :Number
       end
 
-      [:+, :-, :*, :/, :%, :**].each do |selector|
+      %i[+ - * / % **].each do |selector|
         define_method selector do |other|
-          self.class.new value.send(selector, other.value)
+          self.class.new(value.send(selector, other.value))
         end
       end
 
@@ -42,8 +39,9 @@ module Gobstones
         self.class.new(value + 1)
       end
 
+      def to_s
+        "number #{value}"
+      end
     end
-
   end
-
 end

data/lib/gobstones/lang/program.rb

@@ -1,13 +1,11 @@
+require 'gobstones/modules/equality_definition'
 require 'gobstones/runner/execution_context'
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/runner/program_result'
 
 module Gobstones
-
   module Lang
-
     class Program
-
-      include Gobstones::EqualByClass
+      include EqualityDefinition
 
       attr_reader :definitions, :main_definition
 
@@ -16,26 +14,21 @@ module Gobstones
         @main_definition = main_definition
       end
 
-      def ==(other)
-        super(other) &&
-        self.definitions == other.definitions &&
-        self.main_definition == other.main_definition
+      def equality_attributes
+        %i[definitions main_definition]
       end
 
       def evaluate
-        create_context.tap do |context|
-          main_definition.evaluate context
-        end
+        context = create_context
+        return_values = main_definition.evaluate(context)
+        Runner::ProgramResult.new(context.head, return_values)
       end
 
       private
 
       def create_context
-        Gobstones::Runner::ProgramExecutionContext.for self
+        Runner::ProgramExecutionContext.for(self)
       end
-
     end
-
   end
-
 end

data/lib/gobstones/modules/equality_definition.rb

@@ -0,0 +1,23 @@
+module Gobstones
+  module EqualityDefinition
+    def ==(other)
+      class_is_equal?(other) && attributes_are_equal?(other)
+    end
+
+    def equality_attributes
+      []
+    end
+
+    alias_method :eql?, :==
+
+    private
+
+    def class_is_equal?(other)
+      self.class == other.class
+    end
+
+    def attributes_are_equal?(other)
+      equality_attributes.all? { |attr| send(attr) == other.send(attr) }
+    end
+  end
+end

data/lib/gobstones/parser/ast/ast.rb

@@ -1,30 +1,28 @@
 require 'gobstones/lang/all'
 
 module Gobstones
-
   # TODO divide into smaller modules
   module Parser
+    include Lang
 
-    include Gobstones::Lang
-
-    RESERVED_IDS = %w(
+    RESERVED_IDS = %w[
       if else not True False case of while Skip repeatWith in procedure function
       return Mover Sacar Poner BOOM IrAlOrigen VaciarTablero div mod hayBolitas
       nroBolitas puedeMover Norte Sur Este Oeste minBool maxBool minDir maxDir
       minColor maxColor siguiente previo opuesto Verde Rojo Azul Negro Main
-    )
+    ].freeze
 
     def self.ast_node(name, &value_block)
       # TODO check if it is better to have classes
-      mod = Module.new do
-        define_method :value do
+      ast_module = Module.new do
+        define_method(:value) do
           instance_eval(&value_block)
         end
       end
-      const_set name, mod
+      const_set name, ast_module
     end
 
-    ast_node(:IntegerLiteral) { Number.new text_value.to_i }
+    ast_node(:IntegerLiteral) { Number.new(text_value.to_i) }
     ast_node(:BooleanLiteral) { Kernel.const_get(text_value).new }
     ast_node(:ColorLiteral) { Kernel.const_get(text_value).new }
     ast_node(:DirectionLiteral) { Kernel.const_get(text_value).new }
@@ -36,14 +34,14 @@ module Gobstones
     ast_node(:MinDirFuncNode) { MinDir.new }
     ast_node(:MaxDirFuncNode) { MaxDir.new }
 
-    ast_node(:VarNameNode) { VarName.new text_value }
+    ast_node(:VarNameNode) { VarName.new(text_value) }
 
-    ast_node(:NroBolitasFuncNode) { NroBolitas.new gexp.value }
-    ast_node(:HayBolitasFuncNode) { HayBolitas.new gexp.value }
-    ast_node(:PuedeMoverFuncNode) { PuedeMover.new gexp.value }
-    ast_node(:SiguienteFuncNode) { Siguiente.new gexp.value }
-    ast_node(:PrevioFuncNode) { Previo.new gexp.value }
-    ast_node(:OpuestoFuncNode) { Opuesto.new gexp.value }
+    ast_node(:NroBolitasFuncNode) { NroBolitas.new(gexp.value) }
+    ast_node(:HayBolitasFuncNode) { HayBolitas.new(gexp.value) }
+    ast_node(:PuedeMoverFuncNode) { PuedeMover.new(gexp.value) }
+    ast_node(:SiguienteFuncNode) { Siguiente.new(gexp.value) }
+    ast_node(:PrevioFuncNode) { Previo.new(gexp.value) }
+    ast_node(:OpuestoFuncNode) { Opuesto.new(gexp.value) }
 
     ast_node :NopExprNode do
       if sub_exps.empty?
@@ -53,9 +51,9 @@ module Gobstones
         sub_exps.elements.inject(left.value) do |memo, node|
           case node.op.text_value
           when '+'
-            Add.new memo, node.right.value
+            Add.new(memo, node.right.value)
           when '-'
-            Sub.new memo, node.right.value
+            Sub.new(memo, node.right.value)
           end
         end
       end
@@ -67,7 +65,7 @@ module Gobstones
       else
         # it is a nested exp
         sub_exps.elements.inject(left.value) do |memo, node|
-          Mul.new memo, node.right.value
+          Mul.new(memo, node.right.value)
         end
       end
     end
@@ -75,9 +73,9 @@ module Gobstones
     ast_node :DivModExprNode do
       case op.text_value
       when 'div'
-        Div.new left.value, right.value
+        Div.new(left.value, right.value)
       when 'mod'
-        Mod.new left.value, right.value
+        Mod.new(left.value, right.value)
       end
     end
 
@@ -87,7 +85,7 @@ module Gobstones
       else
         # it is a nested exp
         sub_exps.elements.inject(left.value) do |memo, node|
-          Pow.new memo, node.right.value
+          Pow.new(memo, node.right.value)
         end
       end
     end
@@ -98,17 +96,15 @@ module Gobstones
         '<'  => LessThan,  '>'  => GreaterThan,
         '<=' => LessEqual, '>=' => GreaterEqual
       }
-      classes[rop.text_value].new left.value, right.value
+      classes[rop.text_value].new(left.value, right.value)
     end
 
-    ast_node(:NotExprNode) { Not.new exp.value }
-    ast_node(:AndExprNode) { And.new left.value, right.value }
-    ast_node(:OrExprNode) { Or.new left.value, right.value }
+    ast_node(:NotExprNode) { Not.new(exp.value) }
+    ast_node(:AndExprNode) { And.new(left.value, right.value) }
+    ast_node(:OrExprNode) { Or.new(left.value, right.value) }
 
-    ast_node(:ParenthesesExprNode) { EnclosedByParensExpression.new gexp.value }
-    ast_node(:FuncCallNode) do
-      FunctionCall.new func_name.text_value, gexp_tuple.value
-    end
+    ast_node(:ParenthesesExprNode) { EnclosedByParensExpression.new(gexp.value) }
+    ast_node(:FuncCallNode) { FunctionCall.new(func_name.text_value, gexp_tuple.value) }
     ast_node(:TupleExprNode) { exps.empty? ? [] : exps.value }
 
     ast_node :GexpsNode do
@@ -120,44 +116,34 @@ module Gobstones
     end
 
     ast_node(:SkipCmdNode) { Skip.new }
-    ast_node(:BoomCmdNode) { Boom.new string.text_value[1..-2] }
+    ast_node(:BoomCmdNode) { Boom.new(string.text_value[1..-2]) }
 
-    ast_node(:PonerCmdNode) { Poner.new gexp.value }
-    ast_node(:SacarCmdNode) { Sacar.new gexp.value }
-    ast_node(:MoverCmdNode) { Mover.new gexp.value }
+    ast_node(:PonerCmdNode) { Poner.new(gexp.value) }
+    ast_node(:SacarCmdNode) { Sacar.new(gexp.value) }
+    ast_node(:MoverCmdNode) { Mover.new(gexp.value) }
 
     ast_node(:IrAlOrigenCmdNode) { IrAlOrigen.new }
     ast_node(:VaciarTableroCmdNode) { VaciarTablero.new }
 
-    ast_node :ProcCallNode do
-      ProcedureCall.new proc_name.text_value, gexp_tuple.value
-    end
+    ast_node(:ProcCallNode) { ProcedureCall.new(proc_name.text_value, gexp_tuple.value) }
 
-    ast_node :SingleAssignmentNode do
-      SingleAssignment.new var_name.value, gexp.value
-    end
+    ast_node(:SingleAssignmentNode) { SingleAssignment.new(var_name.value, gexp.value) }
+    ast_node(:MultipleAssignmentNode) { MultipleAssignment.new(var_tuple.value, gexp.value) }
 
-    ast_node :MultipleAssignmentNode do
-      MultipleAssignment.new var_tuple.value, gexp.value
-    end
-
-    ast_node :CmdBlockNode do
-      CommandBlock.new create_commands(commands)
-    end
+    ast_node(:CmdBlockNode) { CommandBlock.new(create_commands(commands)) }
 
     ast_node :IfCmdNode do
       if else_clause.empty?
-        IfCmd.new gexp.value, then_block.value
+        If.new(gexp.value, then_block.value)
       else
-        IfElseCmd.new gexp.value, then_block.value, else_clause.else_block.value
+        IfThenElse.new(gexp.value, then_block.value, else_clause.else_block.value)
       end
     end
 
-    ast_node(:WhileCmdNode) { WhileCmd.new gexp.value, cmd_block.value }
+    ast_node(:WhileCmdNode) { While.new(gexp.value, cmd_block.value) }
 
     ast_node :RepeatWithCmdNode do
-      RepeatWithCmd.new var_name.value, range_min.value,
-        range_max.value, cmd_block.value
+      RepeatWith.new(var_name.value, range_min.value, range_max.value, cmd_block.value)
     end
 
     # TODO abstract duplication, very similar to GexpsNode
@@ -173,42 +159,34 @@ module Gobstones
 
     ast_node(:VarTupleNode) do
       variables = vns.empty? ? [] : vns.value
-      VarTuple.new variables
+      VarTuple.new(variables)
     end
 
     ast_node(:ProcedureNode) do
-      Procedure.new proc_name.text_value, var_tuple.value, cmd_block.value
+      Procedure.new(proc_name.text_value, var_tuple.value, cmd_block.value)
     end
 
     ast_node(:FunctionNode) do
-      cmd_block = CommandBlock.new create_commands(commands)
-      Function.new func_name.text_value, var_tuple.value,
-        cmd_block, func_return.value
-    end
-
-    ast_node(:FuncReturnNode) do
-      ReturnFromFunction.new gexp_tuple_1.value
+      cmd_block = CommandBlock.new(create_commands(commands))
+      Function.new(func_name.text_value, var_tuple.value, cmd_block, func_return.value)
     end
 
-    ast_node(:MainReturnNode) do
-      ReturnFromMain.new var_tuple.value
-    end
+    ast_node(:FuncReturnNode) { ReturnFromFunction.new(gexp_tuple_1.value) }
+    ast_node(:MainReturnNode) { ReturnFromMain.new(var_tuple.value) }
 
     ast_node(:MainDefNode) do
-      cmd_block = CommandBlock.new create_commands(commands)
-      return_st = ret.empty? ? NoReturnStatement.new : ret.value
-      Main.new cmd_block, return_st
+      command_block = CommandBlock.new(create_commands(commands))
+      return_statement = ret.empty? ? NoReturnStatement.new : ret.value
+      Main.new(command_block, return_statement)
     end
 
     ast_node(:ProgramNode) do
       defs = definitions.elements.map { |node| node.definition.value }
-      Program.new defs, main_def.value
+      Program.new(defs, main_def.value)
     end
 
     def create_commands(commands)
       commands.elements.map { |node| node.command.value }
     end
-
   end
-
 end