code-ruby 0.3.1 → 0.5.0

data/lib/code/object/decimal.rb

@@ -18,15 +18,63 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
+        value = arguments.first&.value
 
-        if %w[% - / * **].detect { |o| operator == o }
-          number_operation(operator.to_sym, arguments)
-        elsif %w[< <= > >=].detect { |o| operator == o }
-          comparaison(operator.to_sym, arguments)
-        elsif %w[<< >> & | ^].detect { |o| operator == o }
-          integer_operation(operator.to_sym, arguments)
+        if operator == "%"
+          sig(arguments) { ::Code::Object::Number }
+          modulo(value)
         elsif operator == "+"
-          plus(arguments)
+          if value
+            sig(arguments) { ::Code::Object }
+            plus(value)
+          else
+            sig(arguments)
+            self
+          end
+        elsif operator == "-"
+          if value
+            sig(arguments) { ::Code::Object::Number }
+            minus(value)
+          else
+            sig(arguments)
+            unary_minus
+          end
+        elsif operator == "/"
+          sig(arguments) { ::Code::Object::Number }
+          division(value)
+        elsif operator == "*"
+          sig(arguments) { ::Code::Object::Number }
+          multiplication(value)
+        elsif operator == "**"
+          sig(arguments) { ::Code::Object::Number }
+          power(value)
+        elsif operator == "<"
+          sig(arguments) { ::Code::Object::Number }
+          inferior(value)
+        elsif operator == "<="
+          sig(arguments) { ::Code::Object::Number }
+          inferior_or_equal(value)
+        elsif operator == ">"
+          sig(arguments) { ::Code::Object::Number }
+          superior(value)
+        elsif operator == ">="
+          sig(arguments) { ::Code::Object::Number }
+          superior_or_equal(value)
+        elsif operator == "<<"
+          sig(arguments) { ::Code::Object::Number }
+          left_shift(value)
+        elsif operator == ">>"
+          sig(arguments) { ::Code::Object::Number }
+          right_shift(value)
+        elsif operator == "&"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_and(value)
+        elsif operator == "|"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_or(value)
+        elsif operator == "^"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_xor(value)
         else
           super
         end
@@ -42,34 +90,73 @@ class Code
 
       private
 
-      def number_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
-      end
-
-      def integer_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Integer.new(raw.to_i.public_send(operator, other.raw.to_i))
-      end
-
-      def comparaison(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
+      def modulo(other)
+        ::Code::Object::Decimal.new(raw % other.raw)
       end
 
-      def plus(arguments)
-        sig(arguments, ::Code::Object)
-        other = arguments.first.value
-
+      def plus(other)
         if other.is_a?(::Code::Object::Number)
           ::Code::Object::Decimal.new(raw + other.raw)
         else
           ::Code::Object::String.new(to_s + other.to_s)
         end
       end
+
+      def minus(other)
+        ::Code::Object::Decimal.new(raw - other.raw)
+      end
+
+      def division(other)
+        ::Code::Object::Decimal.new(raw / other.raw)
+      end
+
+      def multiplication(other)
+        ::Code::Object::Decimal.new(raw * other.raw)
+      end
+
+      def power(other)
+        ::Code::Object::Decimal.new(raw**other.raw)
+      end
+
+      def inferior(other)
+        ::Code::Object::Boolean.new(raw < other.raw)
+      end
+
+      def inferior_or_equal(other)
+        ::Code::Object::Boolean.new(raw <= other.raw)
+      end
+
+      def superior(other)
+        ::Code::Object::Boolean.new(raw > other.raw)
+      end
+
+      def superior_or_equal(other)
+        ::Code::Object::Boolean.new(raw >= other.raw)
+      end
+
+      def left_shift(other)
+        ::Code::Object::Integer.new(raw.to_i << other.raw.to_i)
+      end
+
+      def right_shift(other)
+        ::Code::Object::Integer.new(raw.to_i >> other.raw.to_i)
+      end
+
+      def bitwise_and(other)
+        ::Code::Object::Integer.new(raw.to_i & other.raw.to_i)
+      end
+
+      def bitwise_or(other)
+        ::Code::Object::Integer.new(raw.to_i | other.raw.to_i)
+      end
+
+      def bitwise_xor(other)
+        ::Code::Object::Integer.new(raw.to_i ^ other.raw.to_i)
+      end
+
+      def unary_minus
+        ::Code::Object::Decimal.new(-raw)
+      end
     end
   end
 end

data/lib/code/object/dictionnary.rb

@@ -10,20 +10,36 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "values"
-          values(arguments)
+          sig(arguments)
+          values
+        elsif operator == "keys"
+          sig(arguments)
+          keys
         elsif operator == "each"
-          each(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
         elsif key?(operator)
-          fetch(operator)
+          result = fetch(operator)
+
+          if result.is_a?(::Code::Object::Function)
+            result.call(**args.merge(operator: nil))
+          else
+            sig(arguments)
+            result
+          end
         else
           super
         end
       end
 
+      def merge(other)
+        ::Code::Object::Dictionnary.new(raw.merge(other.raw))
+      end
+
       def fetch(key)
         raw.fetch(key)
       end
@@ -54,24 +70,25 @@ class Code
 
       private
 
-      def values(arguments)
-        sig(arguments)
+      def keys
+        ::Code::Object::List.new(raw.keys)
+      end
+
+      def values
         ::Code::Object::List.new(raw.values)
       end
 
-      def each(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def each(argument, **globals)
         raw.each do |key, value|
           argument.call(
             arguments: [
               ::Code::Object::Argument.new(key),
               ::Code::Object::Argument.new(value)
             ],
-            context: context,
-            io: io,
+            **globals
           )
         end
+
         self
       end
     end

data/lib/code/object/function.rb

@@ -1,19 +1,18 @@
 class Code
   class Object
     class Function < ::Code::Object
-      def initialize(arguments:, body:)
-        @arguments = arguments
+      def initialize(parameters:, body:)
+        @parameters = parameters
         @body = body
       end
 
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = multi_fetch(args, *::Code::GLOBALS)
 
-        if operator.nil?
-          call_function(args: arguments, context: context, io: io)
+        if operator.nil? || operator == "call"
+          call_function(args: arguments, globals: globals)
         else
           super
         end
@@ -29,36 +28,36 @@ class Code
 
       private
 
-      attr_reader :arguments, :body
+      attr_reader :parameters, :body
 
-      def call_function(args:, context:, io:)
-        new_context = context.deep_dup
+      def call_function(args:, globals:)
+        new_context = deep_dup(globals[:context])
 
-        arguments.each.with_index do |argument, index|
-          if argument.regular?
-            if argument.splat?
-              new_context[argument.name] = ::Code::Object::List.new(
-                args.select(&:regular?).map(&:value),
+        parameters.each.with_index do |parameter, index|
+          if parameter.regular?
+            if parameter.regular_splat?
+              new_context[parameter.name] = ::Code::Object::List.new(
+                args.select(&:regular?).map(&:value)
               )
-            elsif argument.keyword_splat?
-              new_context[argument.name] = ::Code::Object::Dictionnary.new(
-                args.select(&:keyword?).map(&:name_value).to_h,
+            elsif parameter.keyword_splat?
+              new_context[parameter.name] = ::Code::Object::Dictionnary.new(
+                args.select(&:keyword?).map(&:name_value).to_h
               )
             else
               arg = args[index]&.value
-              arg = argument.evaluate(context: new_context, io: io) if arg.nil?
-              new_context[argument.name] = arg
+              arg = parameter.evaluate(**globals) if arg.nil?
+              new_context[parameter.name] = arg
             end
-          elsif argument.keyword?
-            arg = args.detect { |arg| arg.name == argument.name }&.value
-            arg = argument.evaluate(context: new_context, io: io) if arg.nil?
-            new_context[argument.name] = arg
+          elsif parameter.keyword?
+            arg = args.detect { |arg| arg.name == parameter.name }&.value
+            arg = parameter.evaluate(**globals) if arg.nil?
+            new_context[parameter.name] = arg
           else
             raise NotImplementedError
           end
         end
 
-        body.evaluate(context: new_context, io: io)
+        body.evaluate(**globals, context: new_context)
       end
     end
   end

data/lib/code/object/global.rb

@@ -0,0 +1,42 @@
+class Code
+  class Object
+    class Global < ::Code::Object
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        io = args.fetch(:io)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
+
+        if operator == "print"
+          io.print(*arguments.map(&:value))
+          ::Code::Object::Nothing.new
+        elsif operator == "puts"
+          io.puts(*arguments.map(&:value))
+          ::Code::Object::Nothing.new
+        elsif operator == "context"
+          sig(arguments) { ::Code::Object::String }
+          context[value] || ::Code::Object::Nothing.new
+        elsif operator == "evaluate"
+          sig(arguments) { ::Code::Object::String }
+          Code.evaluate(value.raw)
+        else
+          result = context[operator]
+
+          if result && result.is_a?(::Code::Object::Function)
+            result.call(**args.merge(operator: nil))
+          elsif result
+            result
+          else
+            raise ::Code::Error::Undefined.new("#{operator} is not defined")
+          end
+        end
+      end
+
+      def to_s
+        "global"
+      end
+    end
+  end
+end

data/lib/code/object/integer.rb

@@ -18,21 +18,73 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "even?"
-          even?(arguments)
+          sig(arguments)
+          even?
+        elsif operator == "odd?"
+          sig(arguments)
+          odd?
+        elsif operator == "times"
+          sig(arguments) { ::Code::Object::Function }
+          times(value, **globals)
         elsif operator == "*"
-          multiplication(arguments)
+          sig(arguments) { [[::Code::Object::Number, ::Code::Object::String]] }
+          multiplication(value)
         elsif operator == "/"
-          division(arguments)
+          sig(arguments) { ::Code::Object::Number }
+          division(value)
         elsif operator == "+"
-          plus(arguments)
-        elsif %w[% - **].detect { |o| operator == o }
-          integer_or_decimal_operation(operator.to_sym, arguments)
-        elsif %w[> >= < <=].detect { |o| operator == o }
-          comparaison(operator.to_sym, arguments)
-        elsif %w[<< >> & | ^].detect { |o| operator == o }
-          integer_operation(operator.to_sym, arguments)
+          if value
+            sig(arguments) { ::Code::Object }
+            plus(value)
+          else
+            sig(arguments)
+            self
+          end
+        elsif operator == "%"
+          sig(arguments) { ::Code::Object::Number }
+          modulo(value)
+        elsif operator == "-"
+          if value
+            sig(arguments) { ::Code::Object::Number }
+            minus(value)
+          else
+            sig(arguments)
+            unary_minus
+          end
+        elsif operator == "**"
+          sig(arguments) { ::Code::Object::Number }
+          power(value)
+        elsif operator == "<"
+          sig(arguments) { ::Code::Object::Number }
+          inferior(value)
+        elsif operator == "<="
+          sig(arguments) { ::Code::Object::Number }
+          inferior_or_equal(value)
+        elsif operator == ">"
+          sig(arguments) { ::Code::Object::Number }
+          superior(value)
+        elsif operator == ">="
+          sig(arguments) { ::Code::Object::Number }
+          superior_or_equal(value)
+        elsif operator == "<<"
+          sig(arguments) { ::Code::Object::Number }
+          left_shift(value)
+        elsif operator == ">>"
+          sig(arguments) { ::Code::Object::Number }
+          right_shift(value)
+        elsif operator == "&"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_and(value)
+        elsif operator == "|"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_or(value)
+        elsif operator == "^"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_xor(value)
         else
           super
         end
@@ -42,6 +94,10 @@ class Code
         ::Code::Object::Integer.new(raw + 1)
       end
 
+      def +(other)
+        ::Code::Object::Integer.new(raw + other.raw)
+      end
+
       def to_s
         raw.to_s
       end
@@ -52,14 +108,15 @@ class Code
 
       private
 
-      def even?(arguments)
-        sig(arguments)
+      def even?
         ::Code::Object::Boolean.new(raw.even?)
       end
 
-      def multiplication(arguments)
-        sig(arguments, [::Code::Object::Number, ::Code::Object::String])
-        other = arguments.first.value
+      def odd?
+        ::Code::Object::Boolean.new(raw.odd?)
+      end
+
+      def multiplication(other)
         if other.is_a?(::Code::Object::Integer)
           ::Code::Object::Integer.new(raw * other.raw)
         elsif other.is_a?(::Code::Object::Decimal)
@@ -69,10 +126,7 @@ class Code
         end
       end
 
-      def plus(arguments)
-        sig(arguments, ::Code::Object)
-        other = arguments.first.value
-
+      def plus(other)
         if other.is_a?(::Code::Object::Integer)
           ::Code::Object::Integer.new(raw + other.raw)
         elsif other.is_a?(::Code::Object::Decimal)
@@ -82,32 +136,85 @@ class Code
         end
       end
 
-      def division(arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
+      def division(other)
         ::Code::Object::Decimal.new(BigDecimal(raw) / other.raw)
       end
 
-      def integer_or_decimal_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
+      def modulo(other)
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw % other.raw)
+        else
+          ::Code::Object::Decimal.new(raw % other.raw)
+        end
+      end
+
+      def minus(other)
         if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw.public_send(operator, other.raw))
+          ::Code::Object::Integer.new(raw - other.raw)
         else
-          ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
+          ::Code::Object::Decimal.new(raw - other.raw)
         end
       end
 
-      def integer_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Integer.new(raw.to_i.public_send(operator, other.raw.to_i))
+      def unary_minus
+        ::Code::Object::Integer.new(-raw)
+      end
+
+      def power(other)
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw**other.raw)
+        else
+          ::Code::Object::Decimal.new(raw**other.raw)
+        end
       end
 
-      def comparaison(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
+      def inferior(other)
+        ::Code::Object::Boolean.new(raw < other.raw)
+      end
+
+      def inferior_or_equal(other)
+        ::Code::Object::Boolean.new(raw <= other.raw)
+      end
+
+      def superior(other)
+        ::Code::Object::Boolean.new(raw > other.raw)
+      end
+
+      def superior_or_equal(other)
+        ::Code::Object::Boolean.new(raw >= other.raw)
+      end
+
+      def left_shift(other)
+        ::Code::Object::Integer.new(raw << other.raw.to_i)
+      end
+
+      def right_shift(other)
+        ::Code::Object::Integer.new(raw >> other.raw.to_i)
+      end
+
+      def bitwise_and(other)
+        ::Code::Object::Integer.new(raw & other.raw.to_i)
+      end
+
+      def bitwise_or(other)
+        ::Code::Object::Integer.new(raw | other.raw.to_i)
+      end
+
+      def bitwise_xor(other)
+        ::Code::Object::Integer.new(raw ^ other.raw.to_i)
+      end
+
+      def times(argument, **globals)
+        raw.times do |element|
+          argument.call(
+            arguments: [
+              ::Code::Object::Argument.new(::Code::Object::Integer.new(element))
+            ],
+            **globals
+          )
+        end
+
+        self
       end
     end
   end