ree 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26a7ec18c35a9a6d79aad3f91f111bda3338547bc61f6f979ba226d2d5d393ab
-  data.tar.gz: b330811d3d6623eeb4aab2deb85f9687c3cbe53142987cb03bb3938608d7c786
+  metadata.gz: 1b2a4983f915c5d0761d563998b0c5a6fa9bd344d39e61046e47c088b5f53b4d
+  data.tar.gz: 2ec723f70527921b5784989d5f4294a211c5cb5015fe2e16b181990829979dde
 SHA512:
-  metadata.gz: 10e3c7af5fa2f7255884071f960c4795dc2eb32c7974a8ce8daf2a6d44f7a02a09e088a2ceab09fe71a738694279576c325480193e6c6b896ecb830bbc5e99a0
-  data.tar.gz: 2e3f44006a5aa0764f4ff2dc2addd46a23845ba50abec919e770de25d6d8eac02dc1fa93d9b87d5d1ac59387b74f29f66ab812b36acc057f575c48626a8ad27d
+  metadata.gz: f86a204bf1134fbc800898d98e4d379bd9b7e9275db0e4ae6aa278142b6e3af3ef7b5f276eb4a301f711b024737c70dcb0d3e251985854747b0042899fea69f0
+  data.tar.gz: 4e20a1cc184a8b94472c707c07512827e5359626ddf5deb1f9e507fd46f37caac565330d526cee852de120585d3d9b949b809820c3492bc25463cafcd2eea919

data/Gemfile.lock

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

data/lib/ree/benchmark_method_plugin.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class Ree::BenchmarkMethodPlugin
+  def self.active?
+    Ree.benchmark_mode?
+  end
+
+  def initialize(method_name, is_class_method, target)
+    @method_name = method_name
+    @is_class_method = is_class_method
+    @target = target
+  end
+
+  def call
+    config = @target.instance_variable_get(:@__ree_benchmark_config)
+
+    if @method_name == :call
+      if config
+        wrap_as_entry_point(config)
+      else
+        wrap_as_collector
+      end
+    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) }
+    deep = config.fetch(:deep, true)
+    once = config.fetch(:once, false)
+    benchmark_done = false
+
+    alias_target.define_method(method_name) do |*args, **kwargs, &block|
+      if once && benchmark_done
+        Ree::BenchmarkTracer.collect(benchmark_name) do
+          send(method_alias, *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)
+        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|
+      Ree::BenchmarkTracer.collect(benchmark_name) do
+        send(method_alias, *args, **kwargs, &block)
+      end
+    end
+  end
+
+  def build_benchmark_name
+    pkg = @target.instance_variable_get(:@__ree_package_name)
+    obj = @target.instance_variable_get(:@__ree_object_name)
+
+    base = if pkg && obj
+      "#{pkg}/#{obj}"
+    else
+      @target.name || @target.to_s
+    end
+
+    @method_name == :call ? base : "#{base}##{@method_name}"
+  end
+
+  def eigenclass
+    class << @target; self; end
+  end
+end

data/lib/ree/benchmark_tracer.rb

@@ -6,10 +6,12 @@ class Ree::BenchmarkTracer
   THREAD_KEY = :ree_benchmark_tracer
 
   class << self
-    def trace(name)
+    # Entry point trace — starts collection, outputs when root completes
+    def trace(name, output_proc: nil, deep: true)
       stack = Thread.current[THREAD_KEY] ||= []
       node = Node.new(name, Process.clock_gettime(Process::CLOCK_MONOTONIC), nil, [])
       stack.last.children.push(node) if stack.last
+      is_root = stack.empty? || stack.last.nil?
       stack.push(node)
 
       begin
@@ -20,20 +22,55 @@ class Ree::BenchmarkTracer
 
         if stack.empty?
           Thread.current[THREAD_KEY] = nil
-          print_tree(node)
+
+          if output_proc
+            output_proc.call(format_tree(node, deep: deep))
+          else
+            $stdout.puts(format_tree(node, deep: deep))
+          end
         end
       end
 
       result
     end
 
+    # Collector trace — only participates if a trace is already active
+    def collect(name)
+      stack = Thread.current[THREAD_KEY]
+      return yield unless stack && !stack.empty?
+
+      node = Node.new(name, Process.clock_gettime(Process::CLOCK_MONOTONIC), nil, [])
+      stack.last.children.push(node)
+      stack.push(node)
+
+      begin
+        result = yield
+      ensure
+        node.duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - node.start_time
+        stack.pop
+      end
+
+      result
+    end
+
+    # Format tree as a string
+    # deep: false → only root node, deep: true → full tree
+    def format_tree(node, deep: true)
+      lines = []
+      build_tree_lines(node, 0, lines, deep: deep)
+      lines.join("\n")
+    end
+
     private
 
-    def print_tree(node, depth = 0)
+    def build_tree_lines(node, depth, lines, deep: true)
       indent = "  " * depth
       duration_ms = (node.duration * 1000).round(2)
-      $stdout.puts "#{indent}#{node.name} (#{duration_ms}ms)"
-      node.children.each { |child| print_tree(child, depth + 1) }
+      lines << "#{indent}#{node.name} (#{duration_ms}ms)"
+
+      if deep
+        node.children.each { |child| build_tree_lines(child, depth + 1, lines) }
+      end
     end
   end
 end

data/lib/ree/contracts/contractable.rb

@@ -7,11 +7,13 @@ 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
       super
     end
 
     def singleton_method_added(name)
+      return if _ree_method_added_hook_active?
       MethodDecorator.new(name, true, self).call
       super
     end
@@ -28,5 +30,11 @@ module Ree::Contracts
       engine.add_contract(*args, &block)
       EngineProxy.new(engine)
     end
+
+    private
+
+    def _ree_method_added_hook_active?
+      is_a?(Ree::MethodAddedHook)
+    end
   end
 end

data/lib/ree/contracts/method_decorator.rb

@@ -3,6 +3,10 @@
 module Ree::Contracts
   class MethodDecorator
     class << self
+      def active?
+        !Ree::Contracts.no_contracts?
+      end
+
       def decorator_id(target, method_name, is_class_method)
         "#{target.object_id}#{target.name}#{method_name}#{is_class_method}"
       end
@@ -53,8 +57,15 @@ module Ree::Contracts
 
       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
+
       @method_parameters = alias_target
-        .instance_method(method_name)
+        .instance_method(param_source)
         .parameters
         .freeze
 

data/lib/ree/core/object.rb

@@ -5,7 +5,8 @@ class Ree::Object
               :package_name, :factory, :after_init,
               :class_name, :links, :mount_as, :freeze,
               :errors, :linked_const_list, :compiled_frozen,
-              :singleton, :tags, :target, :with_caller
+              :singleton, :tags, :target, :with_caller,
+              :benchmark_config
 
   # @param [Symbol] name Object name
   # @param [String] schema_rpath Object schema path relative to project root dir
@@ -25,6 +26,7 @@ class Ree::Object
     @compiled_frozen = @freeze
     @linked_const_list = []
     @tags = []
+    @benchmark_config = nil
   end
 
   def reset
@@ -39,6 +41,7 @@ class Ree::Object
     @links = []
     @errors = []
     @linked_const_list = []
+    @benchmark_config = nil
   end
 
   # @param [ArrayOf[String]] list List of imported constants, modules and classes
@@ -153,6 +156,14 @@ class Ree::Object
     @after_init = val; self
   end
 
+  def set_benchmark_config(config)
+    @benchmark_config = config; self
+  end
+
+  def benchmark?
+    !!@benchmark_config
+  end
+
   def add_tags(list)
     @tags += list
     @tags.uniq!

data/lib/ree/dsl/object_dsl.rb

@@ -170,6 +170,20 @@ class Ree::ObjectDsl
     @object.set_after_init(method_name)
   end
 
+  def benchmark(once: false, deep: true, output: -> (res) { $stdout.puts(res) })
+    if !@object.fn?
+      raise_error("`benchmark` is only available for fn objects")
+    end
+
+    check_bool(once, :once)
+    check_bool(deep, :deep)
+
+    config = { once: once, deep: deep, output: output }
+    @object.set_benchmark_config(config)
+
+    @object.klass.instance_variable_set(:@__ree_benchmark_config, config)
+  end
+
   # @param [Bool] flag
   def freeze(flag)
     if @object.with_caller? && flag

data/lib/ree/fn_dsl.rb

@@ -3,6 +3,7 @@
 module Ree::FnDSL
   def self.included(base)
     base.extend(ClassMethods)
+    base.extend(Ree::MethodAddedHook)
     base.include(Ree::Inspectable)
   end
 
@@ -20,6 +21,9 @@ module Ree::FnDSL
       dsl.tags(["fn"])
       dsl.object.set_as_compiled(false)
 
+      self.instance_variable_set(:@__ree_package_name, dsl.package.name)
+      self.instance_variable_set(:@__ree_object_name, name)
+
       Ree.container.compile(dsl.package, name)
     end
   end

data/lib/ree/method_added_hook.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ree::MethodAddedHook
+  def method_added(name)
+    plugins = Ree.method_added_plugins.select(&:active?)
+    return super if plugins.empty?
+    return if @__ree_plugin_running
+
+    @__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
+      end
+    ensure
+      @__ree_plugin_running = false
+    end
+
+    super
+  end
+
+  def singleton_method_added(name)
+    plugins = Ree.method_added_plugins.select(&:active?)
+    return super if plugins.empty?
+    return if @__ree_singleton_plugin_running
+
+    @__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
+      end
+    ensure
+      @__ree_singleton_plugin_running = false
+    end
+
+    super
+  end
+end

data/lib/ree/object_compiler.rb

@@ -160,17 +160,6 @@ class Ree::ObjectCompiler
       #{str}
     ruby_eval
 
-    if Ree.benchmark_mode? && object.fn? && !klass.instance_variable_get(:@__ree_benchmark_prepended)
-      klass.instance_variable_set(:@__ree_benchmark_prepended, true)
-      benchmark_name = "#{object.package_name}/#{object.name}"
-      benchmark_mod = Module.new do
-        define_method(:call) do |*args, **kwargs, &block|
-          Ree::BenchmarkTracer.trace(benchmark_name) { super(*args, **kwargs, &block) }
-        end
-      end
-      klass.prepend(benchmark_mod)
-    end
-
     # compile all linked objects
     links.each do |link|
       pckg = @packages_facade.get_loaded_package(link.package_name)

data/lib/ree/version.rb

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

data/lib/ree.rb

@@ -8,6 +8,7 @@ require 'fileutils'
 module Ree
   autoload :Args, 'ree/args'
   autoload :BeanDSL, 'ree/bean_dsl'
+  autoload :BenchmarkMethodPlugin, 'ree/benchmark_method_plugin'
   autoload :BenchmarkTracer, 'ree/benchmark_tracer'
   autoload :CLI, 'ree/cli'
   autoload :Container, 'ree/container'
@@ -22,6 +23,7 @@ module Ree
   autoload :LinkDSL, 'ree/link_dsl'
   autoload :LinkImportBuilder, 'ree/dsl/link_import_builder'
   autoload :LinkValidator, 'ree/core/link_validator'
+  autoload :MethodAddedHook, 'ree/method_added_hook'
   autoload :Object, 'ree/core/object'
   autoload :ObjectCompiler, 'ree/object_compiler'
   autoload :ObjectDsl, 'ree/dsl/object_dsl'
@@ -122,6 +124,14 @@ module Ree
       !!@benchmark_mode
     end
 
+    def method_added_plugins
+      @method_added_plugins ||= []
+    end
+
+    def register_method_added_plugin(plugin_class)
+      method_added_plugins << plugin_class
+    end
+
     def set_logger_debug
       logger.level = Logger::DEBUG
     end
@@ -234,4 +244,7 @@ module Ree
 end
 
 require_relative 'ree/dsl/object_hooks'
-require_relative 'ree/dsl/package_require'
+require_relative 'ree/dsl/package_require'
+
+Ree.register_method_added_plugin(Ree::BenchmarkMethodPlugin)
+Ree.register_method_added_plugin(Ree::Contracts::MethodDecorator)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ree
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 bindir: exe
 cert_chain: []
-date: 2026-02-08 00:00:00.000000000 Z
+date: 2026-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -75,6 +75,7 @@ files:
 - lib/ree.rb
 - lib/ree/args.rb
 - lib/ree/bean_dsl.rb
+- lib/ree/benchmark_method_plugin.rb
 - lib/ree/benchmark_tracer.rb
 - lib/ree/cli.rb
 - lib/ree/cli/generate_package.rb
@@ -166,6 +167,7 @@ files:
 - lib/ree/handlers/template_handler.rb
 - lib/ree/inspectable.rb
 - lib/ree/link_dsl.rb
+- lib/ree/method_added_hook.rb
 - lib/ree/object_compiler.rb
 - lib/ree/package_dsl.rb
 - lib/ree/rspec_link_dsl.rb