code-ruby 0.5.6 → 0.6.1

data/lib/code/object/function.rb

@@ -1,63 +1,90 @@
+# frozen_string_literal: true
+
 class Code
   class Object
     class Function < ::Code::Object
+      attr_reader :parameters, :body
+
       def initialize(parameters:, body:)
         @parameters = parameters
         @body = body
       end
 
+      def self.name
+        "Function"
+      end
+
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
         globals = multi_fetch(args, *::Code::GLOBALS)
 
-        if operator.nil? || operator == "call"
-          call_function(args: arguments, globals: globals)
+        case operator.to_s
+        when "", "call"
+          sig(args) { signature_for_call }
+          code_call(*arguments, **globals)
         else
           super
         end
       end
 
-      def to_s
-        ""
-      end
-
-      def inspect
-        "function"
-      end
-
-      private
-
-      attr_reader :parameters, :body
-
-      def call_function(args:, globals:)
-        new_context = deep_dup(globals[:context])
+      def code_call(*arguments, **globals)
+        context = Context.new({}, parent: globals[:context])
 
         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)
+              context.code_set(
+                parameter.name,
+                List.new(
+                  arguments.select(&:regular?).map(&:value)
+                )
               )
             elsif parameter.keyword_splat?
-              new_context[parameter.name] = ::Code::Object::Dictionnary.new(
-                args.select(&:keyword?).map(&:name_value).to_h
+              context.code_set(
+                parameter.name,
+                Dictionary.new(
+                  arguments.select(&:keyword?).map(&:name_value).to_h
+                )
               )
             else
-              arg = args[index]&.value
-              arg = parameter.evaluate(**globals) if arg.nil?
-              new_context[parameter.name] = arg
+              argument = arguments[index]&.value
+              argument = parameter.evaluate(**globals) if argument.nil?
+              context.code_set(parameter.name, argument)
             end
           elsif parameter.keyword?
-            arg = args.detect { |arg| arg.name == parameter.name }&.value
-            arg = parameter.evaluate(**globals) if arg.nil?
-            new_context[parameter.name] = arg
+            argument = arguments.detect { |argument| argument.name == parameter.name }&.value
+            argument = parameter.evaluate(**globals) if argument.nil?
+            context.code_set(parameter.name, argument)
           else
             raise NotImplementedError
           end
         end
 
-        body.evaluate(**globals, context: new_context)
+        body.evaluate(**globals, context:)
+      end
+
+      def inspect
+        "function"
+      end
+
+      def signature_for_call
+        parameters.inject([]) do |signature, parameter|
+          if parameter.keyword?
+            if signature.last.is_a?(::Hash)
+              signature.last[parameter.name] = Object
+              signature
+            else
+              signature + [{ parameter.name => Object }]
+            end
+          else
+            signature + [Object]
+          end
+        end + [Object.repeat]
+      end
+
+      def to_s
+        ""
       end
     end
   end

data/lib/code/object/global.rb

@@ -1,35 +1,81 @@
+# frozen_string_literal: true
+
 class Code
   class Object
     class Global < ::Code::Object
+      def self.name
+        "Global"
+      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)
+        context = args.fetch(:context)
+        multi_fetch(args, *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)
+        case operator.to_s
+        when "Boolean"
+          sig(args) { Object.maybe }
+          value ? value.code_to_boolean : Class.new(Boolean)
+        when "Class"
+          sig(args) { Object.maybe }
+          value ? value.code_to_class : Class.new(Class)
+        when "Decimal"
+          sig(args) { Object.maybe }
+          value ? value.code_to_decimal : Class.new(Decimal)
+        when "Dictionary"
+          sig(args) { Object.maybe }
+          value ? value.code_to_dictionnary : Class.new(Dictionary)
+        when "Function"
+          sig(args) { Object.maybe }
+          value ? value.code_to_function : Class.new(Function)
+        when "Integer"
+          sig(args) { Object.maybe }
+          value ? value.code_to_integer : Class.new(Integer)
+        when "List"
+          sig(args) { Object.maybe }
+          value ? value.code_to_list : Class.new(List)
+        when "Nothing"
+          sig(args) { Object.maybe }
+          value ? value.code_to_nothing : Class.new(Nothing)
+        when "Number"
+          sig(args) { Object.maybe }
+          value ? value.code_to_number : Class.new(Number)
+        when "Object"
+          sig(args) { Object.maybe }
+          value ? value.code_to_object : Class.new(Object)
+        when "Range"
+          sig(args) { Object.maybe }
+          value ? value.code_to_range : Class.new(Range)
+        when "String"
+          sig(args) { Object.maybe }
+          value ? value.code_to_string : Class.new(String)
+        when "context"
+          sig(args) { String.maybe }
+          value ? context.code_get(value) || Nothing.new : context
+        when "evaluate"
+          sig(args) { Object }
+          Code.evaluate(value.to_s)
+        when "p"
+          sig(args) { Object.repeat }
+          io.puts(*arguments.map(&:value).map(&:inspect)) || Nothing.new
+        when "print"
+          sig(args) { Object.repeat }
+          io.print(*arguments.map(&:value)) || Nothing.new
+        when "puts"
+          sig(args) { Object.repeat }
+          io.puts(*arguments.map(&:value)) || Nothing.new
         else
-          result = context[operator]
+          context = context.lookup!(operator)
+          result = context.code_fetch(operator)
 
-          if result && result.is_a?(::Code::Object::Function)
+          if result.is_a?(Function)
             result.call(**args.merge(operator: nil))
-          elsif result
-            result
           else
-            raise ::Code::Error::Undefined.new("#{operator} is not defined")
+            sig(args)
+            result
           end
         end
       end

data/lib/code/object/identifier_list.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class IdentifierList < List
+      def self.name
+        "IdentifierList"
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        value = arguments.first&.value
+
+        case operator.to_s
+        when /=$/
+          sig(args) { Object }
+
+          context = context.lookup!(raw.first)
+
+          context =
+            raw[..-2].reduce(context) do |context, identifier|
+              context.code_fetch(identifier)
+            end
+
+          context.code_set(
+            raw.last,
+            if operator == "="
+              value
+            else
+              context.fetch(raw.last).call(
+                **args,
+                operator: operator[..-2],
+                arguments: [Argument.new(value)]
+              )
+            end
+          )
+
+          context.code_fetch(raw.last)
+        else
+          super
+        end
+      end
+    end
+  end
+end