gobstones 0.0.1.1 → 0.0.2

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

@@ -1,5 +1,4 @@
 require 'gobstones/lang/definitions/definition_call'
-require 'gobstones/runner/errors/definition_not_found_error'
 
 module Gobstones
 
@@ -9,15 +8,8 @@ module Gobstones
 
       include DefinitionCall
 
-      def evaluate(context)
-        evaluated_args = args.map { |arg| arg.evaluate context }
-        context.program_context.definition_named(name, ->(definition) {
-          definition.evaluate context, evaluated_args
-        }, -> { raise Gobstones::Runner::DefinitionNotFound.new name } )
-      end
-
     end
 
   end
 
-end
+end

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

@@ -1,10 +1,11 @@
-require 'gobstones/lang/commands/assignments'
+require 'gobstones/lang/commands/single_assignment'
 require 'gobstones/lang/commands/command_block'
 require 'gobstones/lang/commands/while_cmd'
 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/equal_by_class'
 
 module Gobstones
 
@@ -12,6 +13,8 @@ module Gobstones
 
     class RepeatWithCmd
 
+      include Gobstones::EqualByClass
+
       attr_reader :var_name, :range_min, :range_max, :cmd_block
 
       def initialize(var_name, range_min, range_max, cmd_block)
@@ -22,7 +25,7 @@ module Gobstones
       end
 
       def ==(other)
-        self.class == other.class &&
+        super(other) &&
         self.var_name == other.var_name &&
         self.range_min == other.range_min &&
         self.range_max == other.range_max &&
@@ -56,18 +59,19 @@ module Gobstones
         #
         # repeatWith var in min..max block
         #        is equivalent to
-        # { var := min; while (var < max) { block; var := siguiente(var) }; block }
+        # 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 = CmdBlock.new [cmd_block, increment]
+        while_block = CommandBlock.new [cmd_block, increment]
         while_cmd = WhileCmd.new while_cond, while_block
-        CmdBlock.new [assign_cmd, while_cmd, cmd_block]
+        if_cond = LessThan.new range_min, range_max
+        IfCmd.new if_cond, CommandBlock.new([assign_cmd, while_cmd, cmd_block])
       end
 
     end
 
   end
 
-end
+end

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

@@ -9,23 +9,25 @@ module Gobstones
     class Sacar < OneArgExpression
 
       def evaluate(context)
-        begin
-          context.head.take_out arg.evaluate(context)
-        rescue RuntimeError => e
-          raise Gobstones::Runner::GobstonesTypeError, e.message
+        with_evaluated_argument_in(context) do |result|
+          context.head.take_out result
         end
+      rescue RuntimeError => e
+        raise Gobstones::Runner::GobstonesTypeError, e.message
       end
 
       def undo(context)
-        context.head.put arg.evaluate(context)
+        with_evaluated_argument_in(context) do |result|
+          context.head.put result
+        end
       end
 
       def opposite
-        Poner.new arg
+        Poner.new argument
       end
 
     end
 
   end
 
-end
+end

data/lib/gobstones/lang/commands/{assignments.rb → single_assignment.rb}

@@ -1,9 +1,13 @@
+require 'gobstones/modules/equal_by_class'
+
 module Gobstones
 
   module Lang
 
     class SingleAssignment
 
+      include Gobstones::EqualByClass
+
       attr_reader :var_name, :expression
 
       def initialize(var_name, expression)
@@ -11,7 +15,7 @@ module Gobstones
       end
 
       def ==(other)
-        self.class == other.class &&
+        super(other) &&
         self.var_name == other.var_name &&
         self.expression == other.expression
       end
@@ -22,8 +26,6 @@ module Gobstones
 
     end
 
-    # TODO implement multiple assignment
-
   end
 
 end

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

@@ -8,7 +8,7 @@ module Gobstones
 
       include Gobstones::EqualByClass
 
-      def evaluate(context=nil)
+      def evaluate(context)
         # do nothing, that's my job :-)
       end
 
@@ -16,4 +16,4 @@ module Gobstones
 
   end
 
-end
+end

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

@@ -16,4 +16,4 @@ module Gobstones
 
   end
 
-end
+end

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

@@ -22,4 +22,4 @@ module Gobstones
 
   end
 
-end
+end

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

@@ -1,4 +1,4 @@
 require 'gobstones/lang/definitions/function'
 require 'gobstones/lang/definitions/main'
 require 'gobstones/lang/definitions/procedure'
-require 'gobstones/lang/definitions/var_tuple'
+require 'gobstones/lang/definitions/var_tuple'

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

@@ -1,22 +1,26 @@
+require 'gobstones/modules/equal_by_class'
+
 module Gobstones
 
   module Lang
 
     class Definition
 
-      attr_reader :name, :args, :body, :return_statement
+      include Gobstones::EqualByClass
+
+      attr_reader :name, :arguments, :body, :return_statement
 
-      def initialize(name, args, body, return_statement)
+      def initialize(name, arguments, body, return_statement)
         @name = name
-        @args = args
+        @arguments = arguments
         @body = body
         @return_statement = return_statement
       end
 
       def ==(other)
-        self.class == other.class &&
+        super(other) &&
         self.name == other.name &&
-        self.args == other.args &&
+        self.arguments == other.arguments &&
         self.body == other.body &&
         self.return_statement == other.return_statement
       end
@@ -25,6 +29,44 @@ module Gobstones
         name == a_name
       end
 
+      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
+        end
+      end
+
+      def create_context_based_on(outer_context)
+        raise 'subclass responsibility'
+      end
+
+      def definition_type
+        raise 'subclass responsibility'
+      end
+
+      private
+
+      def check_number_of_arguments(calling_arguments)
+        raise Gobstones::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}"
+      end
+
+      def in_definition_context_based_on(outer_context, &block)
+        yield create_context_based_on(outer_context)
+      end
+
+      def set_arguments(calling_arguments, procedure_context)
+        arguments.length.times do |index|
+          procedure_context.set arguments.variable_at(index), calling_arguments[index]
+        end
+      end
     end
 
   end

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

@@ -1,20 +1,32 @@
+require 'gobstones/modules/equal_by_class'
+require 'gobstones/runner/errors/definition_not_found_error'
+
 module Gobstones
 
   module Lang
 
     module DefinitionCall
 
-      attr_reader :name, :args
+      include Gobstones::EqualByClass
+
+      attr_reader :name, :arguments
 
-      def initialize(name, args=[])
+      def initialize(name, arguments=[])
         @name = name
-        @args = args
+        @arguments = arguments
       end
 
       def ==(other)
-        self.class == other.class &&
+        super(other) &&
         self.name == other.name &&
-        self.args == other.args
+        self.arguments == other.arguments
+      end
+
+      def evaluate(context)
+        evaluated_arguments = arguments.map { |argument| argument.evaluate context }
+        context.program_context.definition_named(name, ->(definition) {
+          definition.evaluate context, evaluated_arguments
+        }, -> { raise Gobstones::Runner::DefinitionNotFound.new name } )
       end
 
     end

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

@@ -1,4 +1,5 @@
 require 'gobstones/lang/definitions/definition'
+require 'gobstones/runner/execution_context'
 require 'gobstones/lang/definitions/return_from_function'
 
 module Gobstones
@@ -7,6 +8,14 @@ module Gobstones
 
     class Function < Definition
 
+      def definition_type
+        'function'
+      end
+
+      def create_context_based_on(outer_context)
+        Gobstones::Runner::FunctionExecutionContext.based_on outer_context
+      end
+
     end
 
   end

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

@@ -10,7 +10,7 @@ module Gobstones
     class Main < Definition
 
       def initialize(body, return_statement)
-        super('Main', VarTuple.new([]), body, return_statement)
+        super('Main', VarTuple.empty, body, return_statement)
       end
 
       def evaluate(context)

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

@@ -1,15 +1,19 @@
+require 'gobstones/modules/equal_by_class'
+
 module Gobstones
 
   module Lang
 
     class NoReturnStatement
 
-      def ==(other)
-        self.class == other.class
+      include Gobstones::EqualByClass
+
+      def evaluate(context)
+        # nothing to do
       end
 
     end
 
   end
 
-end
+end

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

@@ -1,7 +1,6 @@
 require 'gobstones/lang/definitions/definition'
 require 'gobstones/lang/definitions/no_return_statement'
 require 'gobstones/runner/execution_context'
-require 'gobstones/runner/errors/wrong_arguments_error'
 
 module Gobstones
 
@@ -15,30 +14,16 @@ module Gobstones
         super(name, args, body, NoReturnStatement.new)
       end
 
-      def evaluate(context, arguments=[])
-        check_number_of_arguments arguments
-        procedure_context = Gobstones::Runner::ProcedureExecutionContext.based_on context
-        set_arguments arguments, procedure_context
-        body.evaluate procedure_context
+      def definition_type
+        'procedure'
       end
 
-      private
-
-      def check_number_of_arguments(arguments)
-        if args.length != arguments.length
-          message = "Wrong number of arguments in procedure '#{name}': expected #{args.length}, got #{arguments.length}"
-          raise Gobstones::Runner::WrongArgumentsError, message
-        end
-      end
-
-      def set_arguments(arguments, procedure_context)
-        args.length.times do |index|
-          procedure_context.set args.variables[index], arguments[index]
-        end
+      def create_context_based_on(outer_context)
+        Gobstones::Runner::ProcedureExecutionContext.based_on outer_context
       end
 
     end
 
   end
 
-end
+end

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

@@ -1,9 +1,13 @@
+require 'gobstones/modules/equal_by_class'
+
 module Gobstones
 
   module Lang
 
     class ReturnFromFunction
 
+      include Gobstones::EqualByClass
+
       attr_reader :expressions
 
       def initialize(expressions)
@@ -11,8 +15,14 @@ module Gobstones
       end
 
       def ==(other)
-        self.class == other.class &&
-        self.expressions == other.expressions
+        super(other) && self.expressions == other.expressions
+      end
+
+      def evaluate(context)
+        # TODO think more the case of gexp tuple, should it be a data type instead of a plain list?
+        expressions.size == 1 ?
+            expressions.first.evaluate(context) :
+            expressions.map { |expression| expression.evaluate context }
       end
 
     end

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

@@ -1,9 +1,13 @@
+require 'gobstones/modules/equal_by_class'
+
 module Gobstones
 
   module Lang
 
     class ReturnFromMain
 
+      include Gobstones::EqualByClass
+
       attr_reader :var_tuple
 
       def initialize(var_tuple)
@@ -11,7 +15,7 @@ module Gobstones
       end
 
       def ==(other)
-        self.class == other.class &&
+        super(other) &&
         self.var_tuple == other.var_tuple
       end
 

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

@@ -1,17 +1,25 @@
+require 'gobstones/modules/equal_by_class'
+
 module Gobstones
 
   module Lang
 
     class VarTuple
 
+      include Gobstones::EqualByClass
+
       attr_reader :variables
 
+      def self.empty
+        self.new []
+      end
+
       def initialize(variables)
         @variables = variables
       end
 
       def ==(other)
-        self.class == other.class &&
+        super(other) &&
         self.variables == other.variables
       end
 
@@ -19,6 +27,10 @@ module Gobstones
         variables.length
       end
 
+      def variable_at(index)
+        variables[index]
+      end
+
     end
 
   end