gobstones 0.0.2 → 0.0.3

data/lib/gobstones/lang/expressions/function_call.rb

@@ -1,15 +1,18 @@
+require 'gobstones/lang/expressions/expression'
 require 'gobstones/lang/definitions/definition_call'
 
 module Gobstones
-
   module Lang
-
-    class FunctionCall
-
+    class FunctionCall < Expression
       include DefinitionCall
 
-    end
+      def is_function_call?
+        true
+      end
 
+      def to_s
+        "function call to #{name}"
+      end
+    end
   end
-
 end

data/lib/gobstones/lang/expressions/one_arg_expression.rb

@@ -1,33 +1,25 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/lang/expressions/expression'
 
 module Gobstones
-
   module Lang
-
-    class OneArgExpression
-
-      include Gobstones::EqualByClass
-
+    class OneArgExpression < Expression
       attr_reader :argument
 
       def initialize(argument)
         @argument = argument
       end
 
-      def ==(other)
-        super(other) && argument == other.argument
+      def equality_attributes
+        %i[argument]
       end
 
-      def evaluate(context)
-        raise 'subclass responsibility'
+      def evaluate(_context)
+        subclass_responsibility
       end
 
-      def with_evaluated_argument_in(context, &block)
-        yield argument.evaluate(context)
+      def with_evaluated_argument_in(context)
+        yield(argument.evaluate(context))
       end
-
     end
-
   end
-
 end

data/lib/gobstones/lang/expressions/primitive_functions.rb

@@ -1,74 +1,82 @@
 require 'gobstones/lang/expressions/one_arg_expression'
 require 'gobstones/extensions/boolean'
-require 'gobstones/extensions/fixnum'
+require 'gobstones/extensions/integer'
 require 'gobstones/type_check_result'
 
 module Gobstones
-
   module Lang
-
     class NroBolitas < OneArgExpression
-
       def evaluate(context)
         with_evaluated_argument_in(context) do |result|
           context.head.number_of_balls(result).to_gbs_num
         end
       end
 
+      def to_s
+        'nroBolitas() expression'
+      end
     end
 
     class HayBolitas < OneArgExpression
-
       def evaluate(context)
         with_evaluated_argument_in(context) do |result|
           context.head.are_there_balls?(result).to_gbs_bool
         end
       end
 
+      def to_s
+        'hayBolitas() expression'
+      end
     end
 
     class PuedeMover < OneArgExpression
-
       def evaluate(context)
         with_evaluated_argument_in(context) do |result|
           context.head.can_move?(result).to_gbs_bool
         end
       end
 
+      def to_s
+        'puedeMover() expression'
+      end
+
       def argument_type
         :Direction
       end
 
       def type_check
-        Gobstones::TypeCheckResult.new argument_type, argument.return_type
+        TypeCheckResult.new(argument_type, argument.return_type)
       end
-
     end
 
     class Siguiente < OneArgExpression
-
       def evaluate(context)
-        with_evaluated_argument_in(context) { |result| result.next }
+        with_evaluated_argument_in(context, &:next)
       end
 
+      def to_s
+        'siguiente() expression'
+      end
     end
 
     class Previo < OneArgExpression
-
       def evaluate(context)
-        with_evaluated_argument_in(context) { |result| result.previous }
+        with_evaluated_argument_in(context, &:previous)
       end
 
+      def to_s
+        'previo() expression'
+      end
     end
 
     class Opuesto < OneArgExpression
-
       def evaluate(context)
-        with_evaluated_argument_in(context) { |result| result.opposite }
+        with_evaluated_argument_in(context, &:opposite)
       end
 
+      def to_s
+        'opuesto() expression'
+      end
     end
-
   end
-
 end

data/lib/gobstones/lang/expressions/two_arg_expression.rb

@@ -1,21 +1,19 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/lang/expressions/expression'
 
 module Gobstones
-
   module Lang
-
-    class TwoArgExpression
-
-      include Gobstones::EqualByClass
-
+    class TwoArgExpression < Expression
       attr_reader :left_expr, :right_expr
 
       def self.evaluates_with(selector)
         instance_eval do
           define_method :evaluate do |*args|
             context = args.first
-            left_expr.evaluate(context)
-              .send(selector, right_expr.evaluate(context))
+            left_expr.evaluate(context).send(selector, right_expr.evaluate(context))
+          end
+
+          define_method :to_s do
+            "#{selector} expression"
           end
         end
       end
@@ -25,14 +23,9 @@ module Gobstones
         @right_expr = right
       end
 
-      def ==(other)
-        super(other) &&
-        self.left_expr == other.left_expr &&
-        self.right_expr == other.right_expr
+      def equality_attributes
+        %i[left_expr right_expr]
       end
-
     end
-
   end
-
 end

data/lib/gobstones/lang/expressions/type_bound_functions.rb

@@ -1,66 +1,71 @@
-require 'gobstones/lang/literals/booleans'
-require 'gobstones/lang/literals/colors'
-require 'gobstones/lang/literals/directions'
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/lang/expressions/expression'
+require 'gobstones/lang/literals/boolean'
+require 'gobstones/lang/literals/color'
+require 'gobstones/lang/literals/direction'
+require 'gobstones/runner/execution_context'
 
 module Gobstones
-
   module Lang
-
-    class TypeBoundFunc
-
-      include Gobstones::EqualByClass
-
-    end
+    TypeBoundFunc = Class.new(Expression)
 
     class MinBool < TypeBoundFunc
-
-      def evaluate(context=nil)
+      def evaluate(_context = Runner::NullExecutionContext.new)
         False.new
       end
 
+      def to_s
+        'minBool() expression'
+      end
     end
 
     class MaxBool < TypeBoundFunc
-
-      def evaluate(context=nil)
+      def evaluate(_context = Runner::NullExecutionContext.new)
         True.new
       end
 
+      def to_s
+        'maxBool() expression'
+      end
     end
 
     class MinColor < TypeBoundFunc
-
-      def evaluate(context=nil)
+      def evaluate(_context = Runner::NullExecutionContext.new)
         Azul.new
       end
 
+      def to_s
+        'minColor() expression'
+      end
     end
 
     class MaxColor < TypeBoundFunc
-
-      def evaluate(context=nil)
+      def evaluate(_context = Runner::NullExecutionContext.new)
         Verde.new
       end
 
+      def to_s
+        'maxColor() expression'
+      end
     end
 
     class MinDir < TypeBoundFunc
-
-      def evaluate(context=nil)
+      def evaluate(_context = Runner::NullExecutionContext.new)
         Norte.new
       end
 
+      def to_s
+        'minDir() expression'
+      end
     end
 
     class MaxDir < TypeBoundFunc
-
-      def evaluate(context=nil)
+      def evaluate(_context = Runner::NullExecutionContext.new)
         Oeste.new
       end
 
+      def to_s
+        'maxDir() expression'
+      end
     end
-
   end
-
 end

data/lib/gobstones/lang/expressions/var_name.rb

@@ -1,37 +1,33 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/lang/expressions/expression'
 
 module Gobstones
-
   module Lang
-
-    class VarName
-
-      include Gobstones::EqualByClass
-
+    class VarName < Expression
       attr_reader :name
 
       def initialize(name)
         @name = name
       end
 
-      def ==(var)
-        super(var) && self.name == var.name
+      def equality_attributes
+        %i[name]
       end
 
       def hash
-        @name.hash
+        name.hash
       end
 
       def evaluate(context)
-        context.get self
+        context.get(self)
       end
 
       def named?(a_name)
         name == a_name
       end
 
+      def to_s
+        "variable named '#{name}'"
+      end
     end
-
   end
-
 end

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

@@ -1,4 +1,4 @@
-require 'gobstones/lang/literals/booleans'
-require 'gobstones/lang/literals/colors'
-require 'gobstones/lang/literals/directions'
+require 'gobstones/lang/literals/boolean'
+require 'gobstones/lang/literals/color'
+require 'gobstones/lang/literals/direction'
 require 'gobstones/lang/literals/number'

data/lib/gobstones/lang/literals/{booleans.rb → boolean.rb}

@@ -1,11 +1,8 @@
 require 'gobstones/lang/literals/literal'
 
 module Gobstones
-
   module Lang
-
     class Boolean < Literal
-
       def return_type
         :Boolean
       end
@@ -23,26 +20,24 @@ module Gobstones
       end
 
       def not
-        raise 'subclass responsibility'
+        subclass_responsibility
       end
 
-      def if_true(block, context)
-        raise 'subclass responsibility'
+      def if_true(_block, _context)
+        subclass_responsibility
       end
 
-      def if_false(block, context)
-        raise 'subclass responsibility'
+      def if_false(_block, _context)
+        subclass_responsibility
       end
 
-      def is_true?
-        raise 'subclass responsibility'
+      def true?
+        subclass_responsibility
       end
-
     end
 
     class True < Boolean
-
-      def <(other)
+      def <(_other)
         false
       end
 
@@ -50,7 +45,7 @@ module Gobstones
         other
       end
 
-      def or(other)
+      def or(_other)
         self
       end
 
@@ -60,25 +55,29 @@ module Gobstones
 
       def if_true(block, context)
         block.evaluate context
+        self
       end
 
-      def if_false(block, context)
+      def if_false(_block, _context)
         # nothing to do, I'm true :)
+        self
       end
 
-      def is_true?
+      def true?
         true
       end
 
+      def to_s
+        'True'
+      end
     end
 
     class False < Boolean
-
       def <(other)
         self != other
       end
 
-      def and(other)
+      def and(_other)
         self
       end
 
@@ -90,20 +89,23 @@ module Gobstones
         True.new
       end
 
-      def if_true(block, context)
+      def if_true(_block, _context)
         # nothing to do, I'm false :)
+        self
       end
 
       def if_false(block, context)
         block.evaluate context
+        self
       end
 
-      def is_true?
+      def true?
         false
       end
 
+      def to_s
+        'False'
+      end
     end
-
   end
-
 end