ree 1.2.6 → 1.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4b0c989272201bf193600af16a5d4010842b6d169c4cd97afc9af4bea38d4cd
-  data.tar.gz: 0723ffdd0c7fdfb7220348d7bad7d0af8691f66330c24d64ff9e4d52300802dc
+  metadata.gz: c6f558ae43347082febc5e6f30be8afe0ec5340423b9e2cca23d9b412139ab4e
+  data.tar.gz: 5a1dddb63ed9e12178ff17c3150eb8910fb29b63c564d78302dddf77dcc679a0
 SHA512:
-  metadata.gz: ca5e021ac6507f3679d44fd7fd48068f8918a5990fbd2b993f19e55db06cc1e80c42a23796a9962cdb29b1e20a2e979d7d7765030ca58997979fc7a8bf5cac1d
-  data.tar.gz: d12e9983fea63b43385e686072922b3f8f7bc5dc0e5864a276c3d80d7fcd31e9021ed6c8337814ada8c75cd76add04eab81a903df747833b0bcc69ea30a22e78
+  metadata.gz: f0f8936853687e6facfd21ea46bea355f593b6cf570ac20c6c3406e1764463432623664c829d207bc2e1ccd241baf4e99efc0e409518e596cfcbf5a20af4488a
+  data.tar.gz: 5950203f5babaf701bd5a9c48e9e51fabda3844f9e7645f0912fcd98f1cb109c488211c39119f6af1bcb918c8c34c2e74c8d55e933cc8aabe046dd94c0013fdd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree (1.2.6)
+    ree (1.2.7)
       base64
       commander (~> 5.0.0)
       logger (~> 1.6.5)

data/lib/ree/benchmark_method_plugin.rb

@@ -12,66 +12,48 @@ class Ree::BenchmarkMethodPlugin
   end
 
   def call
-    return unless @method_name == :call && ree_fn?
+    return nil unless @method_name == :call && ree_fn?
 
     config = @target.instance_variable_get(:@__ree_benchmark_config)
-    
+    benchmark_name = build_benchmark_name
+
     if config
-      wrap_as_entry_point(config)
+      build_entry_point_wrapper(benchmark_name, config)
     else
-      wrap_as_collector
+      build_collector_wrapper(benchmark_name)
     end
   end
 
   private
 
-  def wrap_as_entry_point(config)
-    alias_target = @is_class_method ? eigenclass : @target
-    method_name = @method_name
-    method_alias = :"__benchmark_#{method_name}"
-
-    return if alias_target.method_defined?(method_alias)
-
-    alias_target.alias_method(method_alias, method_name)
-
-    benchmark_name = build_benchmark_name
-    output_proc = config[:output] || -> (res) { $stdout.puts(res) }
+  def build_entry_point_wrapper(benchmark_name, config)
+    output_proc = config[:output] || ->(res) { $stdout.puts(res) }
     deep = config.fetch(:deep, true)
     once = config.fetch(:once, false)
     benchmark_done = false
 
-    alias_target.define_method(method_name) do |*args, **kwargs, &block|
+    Proc.new do |instance, next_layer, *args, **kwargs, &block|
       if Ree::BenchmarkTracer.active?
         Ree::BenchmarkTracer.collect(benchmark_name) do
-          send(method_alias, *args, **kwargs, &block)
+          next_layer.call(*args, **kwargs, &block)
         end
       elsif once && benchmark_done
         Ree::BenchmarkTracer.collect(benchmark_name) do
-          send(method_alias, *args, **kwargs, &block)
+          next_layer.call(*args, **kwargs, &block)
         end
       else
         benchmark_done = true if once
         Ree::BenchmarkTracer.trace(benchmark_name, output_proc: output_proc, deep: deep) do
-          send(method_alias, *args, **kwargs, &block)
+          next_layer.call(*args, **kwargs, &block)
         end
       end
     end
   end
 
-  def wrap_as_collector
-    alias_target = @is_class_method ? eigenclass : @target
-    method_name = @method_name
-    method_alias = :"__benchmark_#{method_name}"
-
-    return if alias_target.method_defined?(method_alias)
-
-    alias_target.alias_method(method_alias, method_name)
-
-    benchmark_name = build_benchmark_name
-
-    alias_target.define_method(method_name) do |*args, **kwargs, &block|
+  def build_collector_wrapper(benchmark_name)
+    Proc.new do |instance, next_layer, *args, **kwargs, &block|
       Ree::BenchmarkTracer.collect(benchmark_name) do
-        send(method_alias, *args, **kwargs, &block)
+        next_layer.call(*args, **kwargs, &block)
       end
     end
   end
@@ -99,8 +81,4 @@ class Ree::BenchmarkMethodPlugin
 
     facade.get_object(pkg, obj).fn?
   end
-
-  def eigenclass
-    class << @target; self; end
-  end
 end

data/lib/ree/contracts/contractable.rb

@@ -7,14 +7,14 @@ require_relative 'engine_proxy'
 module Ree::Contracts
   module Contractable
     def method_added(name)
-      return if _ree_method_added_hook_active?
-      MethodDecorator.new(name, false, self).call
+      return super if _ree_method_added_hook_active?
+      MethodDecorator.new(name, false, self).call(plugin_mode: false)
       super
     end
 
     def singleton_method_added(name)
-      return if _ree_method_added_hook_active?
-      MethodDecorator.new(name, true, self).call
+      return super if _ree_method_added_hook_active?
+      MethodDecorator.new(name, true, self).call(plugin_mode: false)
       super
     end
 

data/lib/ree/contracts/method_decorator.rb

@@ -51,21 +51,18 @@ module Ree::Contracts
       @doc = engine.fetch_doc
     end
 
-    def call
-      return if Ree::Contracts.no_contracts?
-      return unless contract_definition
+    def call(plugin_mode: true)
+      return nil if Ree::Contracts.no_contracts?
+      return nil unless contract_definition
 
+      # Store decorator for runtime lookups (still needed)
       self.class.add_decorator(self)
 
-      original_alias = :"__ree_original_#{method_name}"
-      param_source = if alias_target.method_defined?(original_alias)
-        original_alias
-      else
-        method_name
-      end
-
+      # Get method parameters from the method (before aliasing)
+      # Note: We get params from the current method, not __ree_original_#{method_name}
+      # because the alias hasn't been created yet when plugins are called
       @method_parameters = alias_target
-        .instance_method(param_source)
+        .instance_method(method_name)
         .parameters
         .freeze
 
@@ -77,21 +74,13 @@ module Ree::Contracts
 
       @return_validator = Validators.fetch_for(contract_definition.return_contract)
 
-      make_alias
-      make_definition
-    end
-
-    def execute_on(target, args, kwargs, &blk)
-      @args.call(args, kwargs, blk)
-      result = target.send(method_alias, *args, **kwargs, &blk)
-
-      if !return_validator.call(result)
-        raise ReturnContractError, "Invalid return value for #{printed_name}\n  #{
-          return_validator.message(result, 'returns', 0).strip
-        }"
+      if plugin_mode
+        # Plugin mode: Return wrapper lambda for composition
+        build_contract_wrapper
+      else
+        # Legacy mode: Apply wrapper directly (for Contractable standalone usage)
+        apply_contract_wrapper_directly
       end
-
-      result
     end
 
     # Unique ID of this Method Decorator
@@ -99,11 +88,6 @@ module Ree::Contracts
       @id ||= self.class.decorator_id(target, method_name, is_class_method)
     end
 
-    # Alias name for original method
-    def method_alias
-      @method_alias ||= :"__original_#{method_name}_#{SecureRandom.hex}"
-    end
-
     # Target class to be used for alias method definition
     def alias_target
       @alias_target ||= begin
@@ -112,54 +96,90 @@ module Ree::Contracts
       end
     end
 
+    # Public method used by legacy contract wrapper (called from class_eval'd method)
+    def validate_and_call(instance, method_alias, args, kwargs, &blk)
+      @args.call(args, kwargs, blk)
+      result = instance.send(method_alias, *args, **kwargs, &blk)
+
+      unless @return_validator.call(result)
+        raise ReturnContractError, "Invalid return value for #{printed_name}\n  #{
+          @return_validator.message(result, 'returns', 0).strip
+        }"
+      end
+
+      result
+    end
+
     private
 
-    def make_alias
-      alias_target.alias_method(method_alias, method_name)
+    def build_contract_wrapper
+      args_validator = @args
+      return_validator = @return_validator
+      decorator_printed_name = printed_name
+
+      Proc.new do |instance, next_layer, *args, **kwargs, &block|
+        # Validate arguments
+        args_validator.call(args, kwargs, block)
+
+        # Call next layer
+        result = next_layer.call(*args, **kwargs, &block)
+
+        # Validate return value
+        unless return_validator.call(result)
+          raise ReturnContractError, "Invalid return value for #{decorator_printed_name}\n  #{
+            return_validator.message(result, 'returns', 0).strip
+          }"
+        end
+
+        result
+      end
     end
 
-    def make_definition
+    def apply_contract_wrapper_directly
+      # Legacy mode for Contractable standalone usage
+      # Detect visibility BEFORE creating alias
+      visibility = if alias_target.private_instance_methods.include?(method_name)
+        :private
+      elsif alias_target.protected_instance_methods.include?(method_name)
+        :protected
+      else
+        :public
+      end
+
+      # Create our own alias and wrapper
+      method_alias = :"__original_#{method_name}_#{SecureRandom.hex}"
+      alias_target.alias_method(method_alias, method_name)
+
+      args_validator = @args
+      return_validator = @return_validator
+      decorator_printed_name = printed_name
+
       file, line = alias_target.instance_method(method_alias).source_location
 
       alias_target.class_eval(%Q(
         def #{method_name}(*args, **kwargs, &blk)
           decorator = Ree::Contracts::MethodDecorator.get_decorator('#{id}')
-          decorator.execute_on(self, args, kwargs, &blk)
+          decorator.validate_and_call(self, #{method_alias.inspect}, args, kwargs, &blk)
         end
       ), file, line - 3)
 
-      make_private if private_method?
-      make_protected if protected_method?
+      # Restore visibility
+      case visibility
+      when :private
+        alias_target.send(:private, method_name, method_alias)
+      when :protected
+        alias_target.send(:protected, method_name, method_alias)
+      end
     end
 
     def private_method?
-      return target.private_methods.include?(method_alias) if is_class_method
-      target.private_instance_methods.include?(method_alias)
+      return target.private_methods.include?(method_name) if is_class_method
+      target.private_instance_methods.include?(method_name)
     end
 
     def protected_method?
-      return target.protected_methods.include?(method_alias) if is_class_method
-      target.protected_instance_methods.include?(method_alias)
-    end
-
-    def make_private
-      _method_name = method_name
-      _method_alias = method_alias
-
-      alias_target.class_eval do
-        private _method_name
-        private _method_alias
-      end
-    end
-
-    def make_protected
-      _method_name = method_name
-      _method_alias = method_alias
-
-      alias_target.class_eval do
-        protected _method_name
-        protected _method_alias
-      end
+      return target.protected_methods.include?(method_name) if is_class_method
+      target.protected_instance_methods.include?(method_name)
     end
 
     def printed_name

data/lib/ree/method_added_hook.rb

@@ -8,14 +8,22 @@ module Ree::MethodAddedHook
 
     @__ree_plugin_running = true
 
-    original_alias = :"__ree_original_#{name}"
-    remove_method(original_alias) if method_defined?(original_alias)
-    alias_method(original_alias, name)
-
     begin
-      plugins.each do |plugin_class|
-        plugin_class.new(name, false, self).call
+      # Collect wrapper lambdas from plugins (some may return nil)
+      wrappers = plugins.map { |plugin_class| plugin_class.new(name, false, self).call }.compact
+
+      if wrappers.empty?
+        @__ree_plugin_running = false
+        return super
       end
+
+      # Create single alias for original implementation
+      original_alias = :"__ree_original_#{name}"
+      remove_method(original_alias) if method_defined?(original_alias)
+      alias_method(original_alias, name)
+
+      # Compose all wrappers into a single method
+      compose_method(name, original_alias, wrappers)
     ensure
       @__ree_plugin_running = false
     end
@@ -30,22 +38,106 @@ module Ree::MethodAddedHook
 
     @__ree_singleton_plugin_running = true
 
-    original_alias = :"__ree_original_#{name}"
     eigenclass = class << self; self; end
 
-    if eigenclass.method_defined?(original_alias)
-      eigenclass.remove_method(original_alias)
-    end
-    eigenclass.alias_method(original_alias, name)
-
     begin
-      plugins.each do |plugin_class|
-        plugin_class.new(name, true, self).call
+      # Collect wrapper lambdas from plugins (some may return nil)
+      wrappers = plugins.map { |plugin_class| plugin_class.new(name, true, self).call }.compact
+
+      if wrappers.empty?
+        @__ree_singleton_plugin_running = false
+        return super
       end
+
+      # Create single alias for original implementation
+      original_alias = :"__ree_original_#{name}"
+      eigenclass.remove_method(original_alias) if eigenclass.method_defined?(original_alias)
+      eigenclass.alias_method(original_alias, name)
+
+      # Compose all wrappers into a single method
+      compose_singleton_method(eigenclass, name, original_alias, wrappers)
     ensure
       @__ree_singleton_plugin_running = false
     end
 
     super
   end
+
+  private
+
+  def compose_method(method_name, original_alias, wrappers)
+    # Detect original method visibility
+    visibility = if private_method_defined?(original_alias)
+      :private
+    elsif protected_method_defined?(original_alias)
+      :protected
+    else
+      :public
+    end
+
+    # Build executor chain from inside out
+    define_method(method_name) do |*args, **kwargs, &block|
+      # Innermost layer: call the original method
+      # Note: next_layer signature is: ->(){ ... } to be called with .call(*args, **kwargs, &block)
+      executor = ->(*a, **kw, &b) { send(original_alias, *a, **kw, &b) }
+
+      # Wrap from inside out (reverse to make first plugin outermost)
+      wrappers.reverse_each do |wrapper|
+        current_executor = executor
+        # Wrapper receives: (instance, next_layer, *args, **kwargs, &block)
+        # We need to create a next_layer that calls current_executor
+        next_layer = ->(*a, **kw, &b) { current_executor.call(*a, **kw, &b) }
+        executor = ->(*a, **kw, &b) { wrapper.call(self, next_layer, *a, **kw, &b) }
+      end
+
+      # Execute the composed chain
+      executor.call(*args, **kwargs, &block)
+    end
+
+    # Restore original visibility
+    case visibility
+    when :private
+      private method_name
+    when :protected
+      protected method_name
+    end
+  end
+
+  def compose_singleton_method(eigenclass, method_name, original_alias, wrappers)
+    # Detect original method visibility
+    visibility = if eigenclass.private_method_defined?(original_alias)
+      :private
+    elsif eigenclass.protected_method_defined?(original_alias)
+      :protected
+    else
+      :public
+    end
+
+    # Build executor chain from inside out
+    eigenclass.define_method(method_name) do |*args, **kwargs, &block|
+      # Innermost layer: call the original method
+      # Note: next_layer signature is: ->(){ ... } to be called with .call(*args, **kwargs, &block)
+      executor = ->(*a, **kw, &b) { send(original_alias, *a, **kw, &b) }
+
+      # Wrap from inside out (reverse to make first plugin outermost)
+      wrappers.reverse_each do |wrapper|
+        current_executor = executor
+        # Wrapper receives: (instance, next_layer, *args, **kwargs, &block)
+        # We need to create a next_layer that calls current_executor
+        next_layer = ->(*a, **kw, &b) { current_executor.call(*a, **kw, &b) }
+        executor = ->(*a, **kw, &b) { wrapper.call(self, next_layer, *a, **kw, &b) }
+      end
+
+      # Execute the composed chain
+      executor.call(*args, **kwargs, &block)
+    end
+
+    # Restore original visibility
+    case visibility
+    when :private
+      eigenclass.send(:private, method_name)
+    when :protected
+      eigenclass.send(:protected, method_name)
+    end
+  end
 end

data/lib/ree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ree
-  VERSION = "1.2.6"
+  VERSION = "1.2.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ree
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.2.7
 platform: ruby
 authors:
 - Ruslan Gatiyatov