code-ruby 4.0.0 → 4.0.2

data/lib/code/object/function.rb

@@ -5,7 +5,8 @@ class Code
     class Function < Object
       CLASS_DOCUMENTATION = {
         name: "Function",
-        description: "stores a callable block with parameters, captured context, and documentation.",
+        description:
+          "stores a callable block with parameters, captured context, and documentation.",
         examples: [
           "Function.new",
           "((value) => { value + 1 }).call(1)",
@@ -15,16 +16,28 @@ class Code
       INSTANCE_FUNCTIONS = {
         "call" => {
           name: "call",
-          description: "evaluates the function body with the provided arguments.",
+          description:
+            "evaluates the function body with the provided arguments.",
           examples: [
             "((value) => { value + 1 }).call(1)",
             "((name:) => { name }).call(name: :ada)",
             "((a, b = 2) => { a + b }).call(3)"
           ]
         },
+        "new" => {
+          name: "new",
+          description:
+            "evaluates the function body as a constructor with the provided arguments.",
+          examples: [
+            "Widget = () => { self.name = :widget return(self) } Widget.new.name",
+            "User = (name:) => { self.name = name return(self) } User.new(name: :ada).name",
+            "Counter = () => { self.count = 0 return(self) } Counter.new.count"
+          ]
+        },
         "extend" => {
           name: "extend",
-          description: "creates a child function that can call the receiver through super.",
+          description:
+            "creates a child function that can call the receiver through super.",
           examples: [
             "Base = () => { self.name = :base } Child = Base.extend(() => { super() }) Child().name",
             "Base = () => { 1 } Child = Base.extend(() => { super() }) Child()",
@@ -33,7 +46,8 @@ class Code
         },
         "documentation" => {
           name: "documentation",
-          description: "returns or replaces the function documentation dictionary.",
+          description:
+            "returns or replaces the function documentation dictionary.",
           examples: [
             "f = () => { 1 } f.documentation",
             "f = () => { 1 } f.documentation(description: \"returns one\", examples: [\"f()\"])",
@@ -51,7 +65,8 @@ class Code
         },
         "parameters" => {
           name: "parameters",
-          description: "returns a list of parameter descriptors for the function.",
+          description:
+            "returns a list of parameter descriptors for the function.",
           examples: [
             "((name) => { name }).parameters.first.name",
             "((name = :a) => { name }).parameters.first.default",
@@ -76,8 +91,12 @@ class Code
       end
 
       attr_accessor :documentation
-      attr_reader :code_parameters, :code_body, :definition_context,
-                  :instance_functions, :parent
+      attr_reader :code_parameters,
+                  :code_body,
+                  :definition_context,
+                  :definition_object,
+                  :instance_functions,
+                  :parent
 
       def initialize(*args, parent: nil, functions: nil, **_kargs, &_block)
         @code_parameters =
@@ -89,15 +108,17 @@ class Code
 
         @code_body = Code.new(args.second.presence)
         @definition_context = args.third if args.third.is_a?(Context)
+        @definition_object = args.fourth if args.fourth.is_a?(Object)
         @parent = parent.to_code
         self.functions = functions.to_code
         self.functions = Dictionary.new if self.functions.nothing?
         @instance_functions = Dictionary.new
-        self.documentation = Dictionary.new(
-          "name" => String.new(""),
-          "description" => String.new(""),
-          "examples" => List.new
-        )
+        self.documentation =
+          Dictionary.new(
+            "name" => String.new(""),
+            "description" => String.new(""),
+            "examples" => List.new
+          )
 
         self.raw = List.new([code_parameters, code_body])
       end
@@ -107,8 +128,11 @@ class Code
         code_arguments = args.fetch(:arguments, List.new).to_code
         code_value = code_arguments.code_first
         globals = multi_fetch(args, *GLOBALS)
+        operator_name = code_operator.to_s
+        operator_name = "" if operator_name == "new" &&
+          code_has_key?(code_operator).falsy?
 
-        case code_operator.to_s
+        case operator_name
         when "", "call"
           sig(args) { signature_for_call }
           code_call(
@@ -162,6 +186,7 @@ class Code
       )
         code_arguments = arguments.to_code
         code_context = Context.new({}, definition_context || globals[:context])
+        evaluation_object = definition_object || globals.fetch(:previous_object)
         code_self = bound_self.to_code
         if (code_self.nil? || code_self.nothing?) && parent.is_a?(Class)
           code_self = parent.code_call(*arguments, **globals)
@@ -186,7 +211,9 @@ class Code
         end
 
         captures_function_arguments =
-          code_parameters.raw.any? { |parameter| parameter.block? || parameter.blocks? }
+          code_parameters.raw.any? do |parameter|
+            parameter.block? || parameter.blocks?
+          end
         reserved_function_arguments =
           captures_function_arguments ? code_arguments.raw.grep(Function) : []
         code_block_argument =
@@ -206,16 +233,20 @@ class Code
                 end
               )
             elsif code_parameter.keyword_splat?
-              code_arguments.raw.grep(Dictionary).inject(Dictionary.new) do |memo, argument|
-                memo.code_merge!(argument)
-              end
+              code_arguments
+                .raw
+                .grep(Dictionary)
+                .inject(Dictionary.new) do |memo, argument|
+                  memo.code_merge!(argument)
+                end
             elsif code_parameter.block?
               code_block_argument.to_code
             elsif code_parameter.blocks?
               Object::List.new(
-                code_arguments.raw.grep(Function).reject do |argument|
-                  argument == code_block_argument
-                end
+                code_arguments
+                  .raw
+                  .grep(Function)
+                  .reject { |argument| argument == code_block_argument }
               )
             elsif code_parameter.keyword?
               code_arguments
@@ -239,7 +270,8 @@ class Code
                 code_default.code_evaluate(
                   **globals,
                   context: code_context,
-                  trusted_evaluation: true
+                  object: evaluation_object,
+                  previous_object: evaluation_object
                 )
               else
                 code_default
@@ -247,17 +279,20 @@ class Code
           end
 
           code_name = code_parameter.code_name
-          code_context.code_set(code_name, code_argument) unless code_name.blank?
+          unless code_name.blank?
+            code_context.code_set(code_name, code_argument)
+          end
         end
 
-        code_body.code_evaluate(
-          **globals,
-          constructing_literal_classes: constructing_literal_classes,
-          context: code_context,
-          trusted_evaluation: true
-        ).tap do
-          persist_instance_functions(code_self)
-        end
+        code_body
+          .code_evaluate(
+            **globals,
+            constructing_literal_classes: constructing_literal_classes,
+            context: code_context,
+            object: evaluation_object,
+            previous_object: evaluation_object
+          )
+          .tap { persist_instance_functions(code_self) }
       rescue Error::Return => e
         persist_instance_functions(code_self)
         e.code_value
@@ -318,32 +353,33 @@ class Code
       def code_extend(function)
         code_function = function.to_code
 
-        Function.new(
-          code_function.code_parameters,
-          code_function.code_body.raw,
-          code_function.definition_context,
-          parent: self,
-          functions: functions.code_deep_duplicate
-        ).tap do |extended_function|
-          extended_function.instance_functions.code_merge!(instance_functions)
-        end
+        Function
+          .new(
+            code_function.code_parameters,
+            code_function.code_body.raw,
+            code_function.definition_context,
+            code_function.definition_object,
+            parent: self,
+            functions: functions.code_deep_duplicate
+          )
+          .tap do |extended_function|
+            extended_function.instance_functions.code_merge!(instance_functions)
+          end
       end
 
-      def code_deep_duplicate(seen = {})
-        seen.compare_by_identity unless seen.compare_by_identity?
-        return seen[self] if seen.key?(self)
-
+      def code_deep_duplicate
         duplicate = Function.new
-        seen[self] = duplicate
 
         duplicate.code_replace(
-          code_parameters: code_parameters.code_deep_duplicate(seen),
-          code_body: code_body.code_deep_duplicate(seen),
-          definition_context: definition_context&.code_deep_duplicate(seen),
-          parent: parent.is_a?(Function) ? parent.code_deep_duplicate(seen) : parent,
-          functions: functions.code_deep_duplicate(seen),
-          instance_functions: instance_functions.code_deep_duplicate(seen),
-          documentation: documentation.code_deep_duplicate(seen)
+          code_parameters: code_parameters.code_deep_duplicate,
+          code_body: code_body.code_deep_duplicate,
+          definition_context: definition_context&.code_deep_duplicate,
+          definition_object: definition_object,
+          parent:
+            parent.is_a?(Function) ? parent.code_deep_duplicate : parent,
+          functions: functions.code_deep_duplicate,
+          instance_functions: instance_functions.code_deep_duplicate,
+          documentation: documentation.code_deep_duplicate
         )
         duplicate
       end
@@ -355,11 +391,13 @@ class Code
         parent:,
         functions:,
         instance_functions:,
-        documentation:
+        documentation:,
+        definition_object: nil
       )
         @code_parameters = code_parameters
         @code_body = code_body
         @definition_context = definition_context
+        @definition_object = definition_object
         @parent = parent
         self.functions = functions
         @instance_functions = instance_functions
@@ -381,7 +419,9 @@ class Code
           end
 
         Object.sorted_dictionary(
-          parent_functions.code_merge(function_dictionary_for(instance_functions)).raw
+          parent_functions.code_merge(
+            function_dictionary_for(instance_functions)
+          ).raw
         )
       end
 
@@ -440,7 +480,9 @@ class Code
       def persist_instance_functions(code_self)
         return unless code_self.is_a?(Object)
 
-        instance_functions.code_merge!(documentable_instance_functions(code_self))
+        instance_functions.code_merge!(
+          documentable_instance_functions(code_self)
+        )
       end
 
       def documentable_instance_functions(code_self)