gobstones 0.0.2 → 0.0.3

data/lib/gobstones/lang/commands/ir_al_origen.rb

@@ -0,0 +1,15 @@
+require 'gobstones/modules/equality_definition'
+
+module Gobstones
+  module Lang
+    module Commands
+      class IrAlOrigen
+        include EqualityDefinition
+
+        def evaluate(context)
+          context.head.go_to_origin
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/commands/mover.rb

@@ -0,0 +1,23 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+
+module Gobstones
+  module Lang
+    module Commands
+      class Mover < OneArgExpression
+        def evaluate(context)
+          with_evaluated_argument_in(context) do |result|
+            context.head.move result
+          end
+        end
+
+        def undo(context)
+          opposite.evaluate context
+        end
+
+        def opposite
+          Mover.new(argument.opposite)
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/commands/multiple_assignment.rb

@@ -1,35 +1,48 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
 
 module Gobstones
-
   module Lang
+    module Commands
+      class MultipleAssignment
+        include EqualityDefinition
 
-    class MultipleAssignment
+        attr_reader :var_tuple, :expression
 
-      include Gobstones::EqualByClass
+        def initialize(var_tuple, expression)
+          @var_tuple = var_tuple
+          @expression = expression
+        end
 
-      attr_reader :var_tuple, :expression
+        def equality_attributes
+          %i[var_tuple expression]
+        end
 
-      def initialize(var_tuple, expression)
-        @var_tuple, @expression = var_tuple, expression
-      end
+        def evaluate(context)
+          # TODO implement as many simple assignments?
+          validate_expression_is_function_call
+          function_call_result = expression.evaluate(context)
+          check_number_of_arguments(function_call_result)
+          function_call_result.length.times do |index|
+            context.set(var_tuple.variable_at(index), function_call_result[index])
+          end
+        end
 
-      def ==(other)
-        super(other) &&
-        self.var_tuple == other.var_tuple &&
-        self.expression == other.expression
-      end
+        private
 
-      def evaluate(context)
-        # TODO implement as many simple assignments?
-        function_call_result = expression.evaluate(context)
-        function_call_result.length.times do |index|
-          context.set var_tuple.variable_at(index), function_call_result[index]
+        def validate_expression_is_function_call
+          raise Runner::GobstonesTypeError, 'expected a function call in multiple assignment' unless
+              expression.is_function_call?
         end
-      end
 
-    end
+        def check_number_of_arguments(calling_arguments)
+          raise Runner::WrongArgumentsError, wrong_number_of_arguments_message(calling_arguments) if
+              var_tuple.length != calling_arguments.length
+        end
 
+        def wrong_number_of_arguments_message(calling_arguments)
+          "Wrong number of arguments in assignment: expected #{var_tuple.length}, got #{calling_arguments.length}"
+        end
+      end
+    end
   end
-
 end

data/lib/gobstones/lang/commands/poner.rb

@@ -0,0 +1,31 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+require 'gobstones/lang/commands/sacar'
+require 'gobstones/runner/errors/gobstones_type_error'
+
+module Gobstones
+  module Lang
+    module Commands
+      class Poner < OneArgExpression
+        def evaluate(context)
+          with_evaluated_argument_in(context) do |result|
+            context.head.put result
+          end
+        rescue RuntimeError => e
+          raise Runner::GobstonesTypeError, e.message
+        end
+
+        def undo(context)
+          # TODO maybe the command should use the original context
+          # instead of this one (when it was executed)
+          with_evaluated_argument_in(context) do |result|
+            context.head.take_out result
+          end
+        end
+
+        def opposite
+          Sacar.new(argument)
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/commands/procedure_call.rb

@@ -1,15 +1,15 @@
 require 'gobstones/lang/definitions/definition_call'
 
 module Gobstones
-
   module Lang
-
-    class ProcedureCall
-
-      include DefinitionCall
-
+    module Commands
+      class ProcedureCall
+        include Lang::DefinitionCall
+
+        def to_s
+          "procedure call to #{name}"
+        end
+      end
     end
-
   end
-
 end

data/lib/gobstones/lang/commands/repeat_with.rb

@@ -0,0 +1,69 @@
+require 'gobstones/lang/commands/single_assignment'
+require 'gobstones/lang/commands/command_block'
+require 'gobstones/lang/commands/while'
+require 'gobstones/lang/expressions/comparison_expressions'
+require 'gobstones/lang/expressions/primitive_functions'
+require 'gobstones/runner/errors/gobstones_runtime_error'
+require 'gobstones/runner/errors/gobstones_type_error'
+require 'gobstones/modules/equality_definition'
+
+module Gobstones
+  module Lang
+    module Commands
+      class RepeatWith
+        include EqualityDefinition
+
+        attr_reader :var_name, :range_min, :range_max, :cmd_block
+
+        def initialize(var_name, range_min, range_max, cmd_block)
+          @var_name = var_name
+          @range_min = range_min
+          @range_max = range_max
+          @cmd_block = cmd_block
+        end
+
+        def equality_attributes
+          %i[var_name range_min range_max cmd_block]
+        end
+
+        def evaluate(context)
+          validate_range_values context
+          validate_index_variable_not_defined context
+          while_based_equivalent_cmd.evaluate context
+          clear_index_variable_from context
+        end
+
+        private
+
+        def clear_index_variable_from(context)
+          context.clear var_name
+        end
+
+        def validate_range_values(context)
+          raise Runner::GobstonesTypeError, "types don't match in range values" \
+          unless range_min.evaluate(context).same_type_as(range_max.evaluate(context))
+        end
+
+        def validate_index_variable_not_defined(context)
+          raise Runner::GobstonesRuntimeError, "index variable can't be used because it's already defined" \
+          if context.has_variable_named?(var_name.name)
+        end
+
+        def while_based_equivalent_cmd
+          #
+          # repeatWith var in min..max block
+          #        is equivalent to
+          # if (min <= max) { var := min; while (var < max) { block; var := siguiente(var) }; block }
+          #
+          assign_cmd = SingleAssignment.new(var_name, range_min)
+          while_cond = LessThan.new(var_name, range_max)
+          increment = SingleAssignment.new(var_name, Siguiente.new(var_name))
+          while_block = CommandBlock.new([cmd_block, increment])
+          while_cmd = While.new(while_cond, while_block)
+          if_cond = LessEqual.new(range_min, range_max)
+          If.new(if_cond, CommandBlock.new([assign_cmd, while_cmd, cmd_block]))
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/commands/sacar.rb

@@ -0,0 +1,29 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+require 'gobstones/lang/commands/poner'
+require 'gobstones/runner/errors/gobstones_type_error'
+
+module Gobstones
+  module Lang
+    module Commands
+      class Sacar < OneArgExpression
+        def evaluate(context)
+          with_evaluated_argument_in(context) do |result|
+            context.head.take_out result
+          end
+        rescue RuntimeError => e
+          raise Runner::GobstonesTypeError, e.message
+        end
+
+        def undo(context)
+          with_evaluated_argument_in(context) do |result|
+            context.head.put result
+          end
+        end
+
+        def opposite
+          Poner.new(argument)
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/commands/single_assignment.rb

@@ -1,31 +1,26 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
 
 module Gobstones
-
   module Lang
+    module Commands
+      class SingleAssignment
+        include EqualityDefinition
 
-    class SingleAssignment
-
-      include Gobstones::EqualByClass
+        attr_reader :var_name, :expression
 
-      attr_reader :var_name, :expression
-
-      def initialize(var_name, expression)
-        @var_name, @expression = var_name, expression
-      end
+        def initialize(var_name, expression)
+          @var_name = var_name
+          @expression = expression
+        end
 
-      def ==(other)
-        super(other) &&
-        self.var_name == other.var_name &&
-        self.expression == other.expression
-      end
+        def equality_attributes
+          %i[var_name expression]
+        end
 
-      def evaluate(context)
-        context.set var_name, expression.evaluate(context)
+        def evaluate(context)
+          context.set(var_name, expression.evaluate(context))
+        end
       end
-
     end
-
   end
-
 end

data/lib/gobstones/lang/commands/skip.rb

@@ -0,0 +1,15 @@
+require 'gobstones/modules/equality_definition'
+
+module Gobstones
+  module Lang
+    module Commands
+      class Skip
+        include EqualityDefinition
+
+        def evaluate(_context)
+          # do nothing, that's my job :-)
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/commands/vaciar_tablero.rb

@@ -0,0 +1,15 @@
+require 'gobstones/modules/equality_definition'
+
+module Gobstones
+  module Lang
+    module Commands
+      class VaciarTablero
+        include EqualityDefinition
+
+        def evaluate(context)
+          context.board.empty!
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/commands/while.rb

@@ -0,0 +1,20 @@
+require 'gobstones/lang/commands/conditional'
+require 'gobstones/runner/errors/gobstones_runtime_error'
+
+module Gobstones
+  module Lang
+    module Commands
+      class While < Conditional
+        STACK_LIMIT = 10_000
+
+        def evaluate(context, stack_size = 0)
+          raise Runner::GobstonesRuntimeError, 'stack overflow' if stack_size == STACK_LIMIT
+          return unless evaluate_condition(context).true?
+
+          then_block.evaluate(context)
+          evaluate(context, stack_size + 1)
+        end
+      end
+    end
+  end
+end

data/lib/gobstones/lang/definitions/definition.rb

@@ -1,12 +1,11 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
+require 'gobstones/runner/errors/wrong_arguments_error'
+require 'error_handling_protocol'
 
 module Gobstones
-
   module Lang
-
     class Definition
-
-      include Gobstones::EqualByClass
+      include EqualityDefinition
 
       attr_reader :name, :arguments, :body, :return_statement
 
@@ -17,49 +16,45 @@ module Gobstones
         @return_statement = return_statement
       end
 
-      def ==(other)
-        super(other) &&
-        self.name == other.name &&
-        self.arguments == other.arguments &&
-        self.body == other.body &&
-        self.return_statement == other.return_statement
+      def equality_attributes
+        %i[name arguments body return_statement]
       end
 
       def named?(a_name)
         name == a_name
       end
 
-      def evaluate(context, calling_arguments=[])
+      def evaluate(context, calling_arguments = [])
         check_number_of_arguments calling_arguments
         in_definition_context_based_on(context) do |definition_context|
           set_arguments calling_arguments, definition_context
           body.evaluate definition_context
-          return return_statement.evaluate definition_context
+          return return_statement.evaluate(definition_context)
         end
       end
 
-      def create_context_based_on(outer_context)
-        raise 'subclass responsibility'
+      def create_context_based_on(_outer_context)
+        subclass_responsibility
       end
 
       def definition_type
-        raise 'subclass responsibility'
+        subclass_responsibility
       end
 
       private
 
       def check_number_of_arguments(calling_arguments)
-        raise Gobstones::Runner::WrongArgumentsError, wrong_number_of_arguments_message(calling_arguments) if
+        raise Runner::WrongArgumentsError, wrong_number_of_arguments_message(calling_arguments) if
             arguments.length != calling_arguments.length
       end
 
       def wrong_number_of_arguments_message(calling_arguments)
-        "Wrong number of arguments in #{definition_type} '#{name}':" +
-            " expected #{arguments.length}, got #{calling_arguments.length}"
+        "Wrong number of arguments in #{definition_type} '#{name}':" \
+          " expected #{arguments.length}, got #{calling_arguments.length}"
       end
 
-      def in_definition_context_based_on(outer_context, &block)
-        yield create_context_based_on(outer_context)
+      def in_definition_context_based_on(outer_context)
+        yield(create_context_based_on(outer_context))
       end
 
       def set_arguments(calling_arguments, procedure_context)
@@ -68,7 +63,5 @@ module Gobstones
         end
       end
     end
-
   end
-
 end