gobstones 0.0.2 → 0.0.3

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

@@ -1,36 +1,28 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
 require 'gobstones/runner/errors/definition_not_found_error'
 
 module Gobstones
-
   module Lang
-
     module DefinitionCall
-
-      include Gobstones::EqualByClass
+      include EqualityDefinition
 
       attr_reader :name, :arguments
 
-      def initialize(name, arguments=[])
+      def initialize(name, arguments = [])
         @name = name
         @arguments = arguments
       end
 
-      def ==(other)
-        super(other) &&
-        self.name == other.name &&
-        self.arguments == other.arguments
+      def equality_attributes
+        %i[name arguments]
       end
 
       def evaluate(context)
-        evaluated_arguments = arguments.map { |argument| argument.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 } )
+        }, -> { raise Runner::DefinitionNotFound, name })
       end
-
     end
-
   end
-
 end

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

@@ -3,21 +3,15 @@ require 'gobstones/runner/execution_context'
 require 'gobstones/lang/definitions/return_from_function'
 
 module Gobstones
-
   module Lang
-
     class Function < Definition
-
       def definition_type
         'function'
       end
 
       def create_context_based_on(outer_context)
-        Gobstones::Runner::FunctionExecutionContext.based_on outer_context
+        Runner::FunctionExecutionContext.based_on(outer_context)
       end
-
     end
-
   end
-
 end

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

@@ -4,23 +4,16 @@ require 'gobstones/lang/definitions/no_return_statement'
 require 'gobstones/lang/definitions/return_from_main'
 
 module Gobstones
-
   module Lang
-
     class Main < Definition
-
       def initialize(body, return_statement)
         super('Main', VarTuple.empty, body, return_statement)
       end
 
       def evaluate(context)
-        # evaluate body
         body.evaluate context
-        # evaluate return
+        return_statement.evaluate(context) || []
       end
-
     end
-
   end
-
 end

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

@@ -1,19 +1,13 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
 
 module Gobstones
-
   module Lang
-
     class NoReturnStatement
-
-      include Gobstones::EqualByClass
+      include EqualityDefinition
 
       def evaluate(context)
         # nothing to do
       end
-
     end
-
   end
-
 end

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

@@ -3,11 +3,8 @@ require 'gobstones/lang/definitions/no_return_statement'
 require 'gobstones/runner/execution_context'
 
 module Gobstones
-
   module Lang
-
     class Procedure < Definition
-
       # TODO rename args to a better name, args_tuple?
 
       def initialize(name, args, body)
@@ -19,11 +16,8 @@ module Gobstones
       end
 
       def create_context_based_on(outer_context)
-        Gobstones::Runner::ProcedureExecutionContext.based_on outer_context
+        Runner::ProcedureExecutionContext.based_on(outer_context)
       end
-
     end
-
   end
-
 end

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

@@ -1,12 +1,9 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
 
 module Gobstones
-
   module Lang
-
     class ReturnFromFunction
-
-      include Gobstones::EqualByClass
+      include EqualityDefinition
 
       attr_reader :expressions
 
@@ -14,19 +11,15 @@ module Gobstones
         @expressions = expressions
       end
 
-      def ==(other)
-        super(other) && self.expressions == other.expressions
+      def equality_attributes
+        %i[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 }
+        evaluated_expressions = expressions.map { |expression| expression.evaluate(context) }
+        evaluated_expressions.size == 1 ? evaluated_expressions.first : evaluated_expressions
       end
-
     end
-
   end
-
 end

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

@@ -1,12 +1,9 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
 
 module Gobstones
-
   module Lang
-
     class ReturnFromMain
-
-      include Gobstones::EqualByClass
+      include EqualityDefinition
 
       attr_reader :var_tuple
 
@@ -14,13 +11,21 @@ module Gobstones
         @var_tuple = var_tuple
       end
 
-      def ==(other)
-        super(other) &&
-        self.var_tuple == other.var_tuple
+      def equality_attributes
+        %i[var_tuple]
       end
 
-    end
+      def evaluate(context)
+        Hash[evaluated_variables(context)]
+      end
 
-  end
+      private
 
+      def evaluated_variables(context)
+        var_tuple.variables.map do |variable|
+          [variable, context.get(variable)]
+        end
+      end
+    end
+  end
 end

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

@@ -1,26 +1,27 @@
-require 'gobstones/modules/equal_by_class'
+require 'gobstones/modules/equality_definition'
+require 'gobstones/extensions/string'
 
 module Gobstones
-
   module Lang
-
     class VarTuple
-
-      include Gobstones::EqualByClass
+      include EqualityDefinition
 
       attr_reader :variables
 
       def self.empty
-        self.new []
+        new([])
+      end
+
+      def self.with_names(var_names)
+        new(var_names.map(&:to_var_name))
       end
 
       def initialize(variables)
         @variables = variables
       end
 
-      def ==(other)
-        super(other) &&
-        self.variables == other.variables
+      def equality_attributes
+        %i[variables]
       end
 
       def length
@@ -30,9 +31,6 @@ module Gobstones
       def variable_at(index)
         variables[index]
       end
-
     end
-
   end
-
 end

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

@@ -1,52 +1,42 @@
 require 'gobstones/lang/expressions/two_arg_expression'
 require 'gobstones/runner/errors/gobstones_runtime_error'
+require 'gobstones/runner/execution_context'
+require 'gobstones/extensions/integer'
 
 module Gobstones
-
   module Lang
+    class ArithmeticExpression < TwoArgExpression
+      def self.numbers(first, second)
+        new(first.to_gbs_num, second.to_gbs_num)
+      end
+    end
 
-    class Add < TwoArgExpression
-
+    class Add < ArithmeticExpression
       evaluates_with :+
-
     end
 
-    class Sub < TwoArgExpression
-
+    class Sub < ArithmeticExpression
       evaluates_with :-
-
     end
 
-    class Mul < TwoArgExpression
-
+    class Mul < ArithmeticExpression
       evaluates_with :*
-
     end
 
-    class Div < TwoArgExpression
-
-      def evaluate(context=nil)
-        begin
-          left_expr.evaluate(context) / right_expr.evaluate(context)
-        rescue ZeroDivisionError
-          raise Gobstones::Runner::GobstonesRuntimeError, 'zero division'
-        end
+    class Div < ArithmeticExpression
+      def evaluate(context = Runner::NullExecutionContext.new)
+        left_expr.evaluate(context) / right_expr.evaluate(context)
+      rescue ZeroDivisionError
+        raise Runner::GobstonesRuntimeError, 'zero division'
       end
-
     end
 
-    class Mod < TwoArgExpression
-
+    class Mod < ArithmeticExpression
       evaluates_with :%
-
     end
 
-    class Pow < TwoArgExpression
-
+    class Pow < ArithmeticExpression
       evaluates_with :**
-
     end
-
   end
-
 end

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

@@ -2,29 +2,23 @@ require 'gobstones/lang/expressions/one_arg_expression'
 require 'gobstones/lang/expressions/two_arg_expression'
 
 module Gobstones
-
   module Lang
-
     class Not < OneArgExpression
-
       def evaluate(context)
-        with_evaluated_argument_in(context) { |result| result.not }
+        with_evaluated_argument_in(context, &:not)
       end
 
+      def to_s
+        'Not expression'
+      end
     end
 
     class And < TwoArgExpression
-
       evaluates_with :and
-
     end
 
     class Or < TwoArgExpression
-
       evaluates_with :or
-
     end
-
   end
-
 end

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

@@ -1,45 +1,29 @@
 require 'gobstones/lang/expressions/two_arg_expression'
 
 module Gobstones
-
   module Lang
-
     class Equal < TwoArgExpression
-
       evaluates_with :equal
-
     end
 
     class NotEqual < TwoArgExpression
-
       evaluates_with :not_equal
-
     end
 
     class LessThan < TwoArgExpression
-
       evaluates_with :less_than
-
     end
 
     class LessEqual < TwoArgExpression
-
       evaluates_with :less_equal
-
     end
 
     class GreaterEqual < TwoArgExpression
-
       evaluates_with :greater_equal
-
     end
 
     class GreaterThan < TwoArgExpression
-
       evaluates_with :greater_than
-
     end
-
   end
-
 end

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

@@ -1,17 +1,15 @@
 require 'gobstones/lang/expressions/one_arg_expression'
 
 module Gobstones
-
   module Lang
-
     class EnclosedByParensExpression < OneArgExpression
-
       def evaluate(context)
         with_evaluated_argument_in(context) { |result| result }
       end
 
+      def to_s
+        'Expression enclosed in parentheses'
+      end
     end
-
   end
-
 end

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

@@ -0,0 +1,18 @@
+require 'gobstones/modules/equality_definition'
+require 'error_handling_protocol'
+
+module Gobstones
+  module Lang
+    class Expression
+      include EqualityDefinition
+
+      def evaluate(_context)
+        subclass_responsibility
+      end
+
+      def is_function_call?
+        false
+      end
+    end
+  end
+end