lazy_init 0.1.1 → 0.2.0

data/lib/lazy_init/instance_methods.rb

@@ -84,91 +84,109 @@ module LazyInit
     def lazy_once(max_entries: nil, ttl: nil, &block)
       raise ArgumentError, 'Block is required' unless block
 
-      # apply global configuration defaults
+      # Apply global configuration defaults
       max_entries ||= LazyInit.configuration.max_lazy_once_entries
       ttl ||= LazyInit.configuration.lazy_once_ttl
 
-      # generate cache key from caller location for automatic memoization
-      call_location = caller_locations(1, 1).first
-      location_key = "#{call_location.path}:#{call_location.lineno}"
+      # Use simplified version ONLY if no advanced features needed
+      if LazyInit::RubyCapabilities::IMPROVED_EVAL_PERFORMANCE &&
+         max_entries.nil? && ttl.nil?
 
-      # ensure thread-safe cache initialization
-      @lazy_once_mutex ||= Mutex.new
+        # Fast path for Ruby 3+ with no TTL/limits
+        location_key = caller_locations(1, 1).first.lineno
+
+        @lazy_once_simple ||= {}
+        return @lazy_once_simple[location_key] if @lazy_once_simple.key?(location_key)
+
+        result = block.call
+        @lazy_once_simple[location_key] = result
+        result
+      else
+        # Use existing full implementation for TTL/limits/statistics
+        # (existing lazy_once code with all features)
+
+        # Generate cache key from caller location for automatic memoization
+        call_location = caller_locations(1, 1).first
+        location_key = "#{call_location.path}:#{call_location.lineno}"
+
+        # Ensure thread-safe cache initialization
+        @lazy_once_mutex ||= Mutex.new
+
+        # Fast path: check cache outside mutex for performance
+        if @lazy_once_cache&.key?(location_key)
+          cached_entry = @lazy_once_cache[location_key]
 
-      # fast path: check cache outside mutex for performance
-      if @lazy_once_cache&.key?(location_key)
-        cached_entry = @lazy_once_cache[location_key]
-
-        # handle TTL expiration if configured
-        if ttl && Time.now - cached_entry[:created_at] > ttl
-          @lazy_once_mutex.synchronize do
-            # double-check TTL after acquiring lock
-            if @lazy_once_cache&.key?(location_key)
-              cached_entry = @lazy_once_cache[location_key]
-              if Time.now - cached_entry[:created_at] > ttl
-                @lazy_once_cache.delete(location_key)
-              else
-                # entry is still valid, update access tracking and return
+          # Handle TTL expiration if configured
+          if ttl && Time.now - cached_entry[:created_at] > ttl
+            @lazy_once_mutex.synchronize do
+              # Double-check TTL after acquiring lock
+              if @lazy_once_cache&.key?(location_key)
+                cached_entry = @lazy_once_cache[location_key]
+                if Time.now - cached_entry[:created_at] > ttl
+                  @lazy_once_cache.delete(location_key)
+                else
+                  # Entry is still valid, update access tracking and return
+                  cached_entry[:access_count] += 1
+                  cached_entry[:last_accessed] = Time.now if ttl
+                  return cached_entry[:value]
+                end
+              end
+            end
+          else
+            # Cache hit: update access tracking in thread-safe manner
+            @lazy_once_mutex.synchronize do
+              if @lazy_once_cache&.key?(location_key)
+                cached_entry = @lazy_once_cache[location_key]
                 cached_entry[:access_count] += 1
                 cached_entry[:last_accessed] = Time.now if ttl
                 return cached_entry[:value]
               end
             end
           end
-        else
-          # cache hit: update access tracking in thread-safe manner
-          @lazy_once_mutex.synchronize do
-            if @lazy_once_cache&.key?(location_key)
-              cached_entry = @lazy_once_cache[location_key]
+        end
+
+        # Slow path: compute value and cache result
+        @lazy_once_mutex.synchronize do
+          # Double-check pattern
+          if @lazy_once_cache&.key?(location_key)
+            cached_entry = @lazy_once_cache[location_key]
+
+            # Verify TTL hasn't expired while we waited for the lock
+            if ttl && Time.now - cached_entry[:created_at] > ttl
+              @lazy_once_cache.delete(location_key)
+            else
               cached_entry[:access_count] += 1
               cached_entry[:last_accessed] = Time.now if ttl
               return cached_entry[:value]
             end
           end
-        end
-      end
-
-      # slow path: compute value and cache result
-      @lazy_once_mutex.synchronize do
-        # double-check pattern: another thread might have computed while we waited
-        if @lazy_once_cache&.key?(location_key)
-          cached_entry = @lazy_once_cache[location_key]
-
-          # verify TTL hasn't expired while we waited for the lock
-          if ttl && Time.now - cached_entry[:created_at] > ttl
-            @lazy_once_cache.delete(location_key)
-          else
-            cached_entry[:access_count] += 1
-            cached_entry[:last_accessed] = Time.now if ttl
-            return cached_entry[:value]
-          end
-        end
 
-        # initialize cache storage if this is the first lazy_once call
-        @lazy_once_cache ||= {}
+          # Initialize cache storage if this is the first lazy_once call
+          @lazy_once_cache ||= {}
 
-        # perform LRU cleanup if cache is getting too large
-        cleanup_lazy_once_cache_simple!(max_entries) if @lazy_once_cache.size >= max_entries
+          # Perform LRU cleanup if cache is getting too large
+          cleanup_lazy_once_cache_simple!(max_entries) if @lazy_once_cache.size >= max_entries
 
-        # compute the value and store in cache with minimal metadata
-        begin
-          computed_value = block.call
+          # Compute the value and store in cache
+          begin
+            computed_value = block.call
 
-          # create cache entry with minimal required metadata for performance
-          cache_entry = {
-            value: computed_value,
-            access_count: 1
-          }
+            # Create cache entry with metadata
+            cache_entry = {
+              value: computed_value,
+              access_count: 1
+            }
 
-          # add optional metadata only when features are actually used
-          cache_entry[:created_at] = Time.now if ttl
-          cache_entry[:last_accessed] = Time.now if ttl
+            # Add optional metadata only when features are actually used
+            cache_entry[:created_at] = Time.now if ttl
+            cache_entry[:last_accessed] = Time.now if ttl
 
-          @lazy_once_cache[location_key] = cache_entry
-          computed_value
-        rescue StandardError => e
-          # don't cache exceptions to keep implementation simple
-          raise
+            @lazy_once_cache[location_key] = cache_entry
+            computed_value
+          rescue StandardError => e
+            # Don't cache exceptions to keep implementation simple
+            raise
+          end
         end
       end
     end
@@ -232,14 +250,20 @@ module LazyInit
     def lazy_once_statistics
       @lazy_once_mutex ||= Mutex.new
       @lazy_once_mutex.synchronize do
+        simple_cache = @lazy_once_simple || {}
+        complex_cache = @lazy_once_cache || {}
+
+        total_entries = simple_cache.size + complex_cache.size
+        total_accesses = complex_cache.values.sum { |entry| entry[:access_count] || 1 } + simple_cache.size
+
         # return empty stats if no cache exists yet
         unless @lazy_once_cache
           return {
-            total_entries: 0,
-            computed_entries: 0,
+            total_entries: total_entries,
+            computed_entries: total_entries,
             oldest_entry: nil,
             newest_entry: nil,
-            total_accesses: 0,
+            total_accesses: total_accesses,
             average_accesses: 0
           }
         end

data/lib/lazy_init/ruby_capabilities.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LazyInit
+  # Detects Ruby version capabilities for performance optimizations.
+  #
+  # This module automatically detects which Ruby version features are available
+  # and enables appropriate optimizations without requiring configuration.
+  # All detection is done at load time for zero runtime overhead.
+  #
+  # @since 0.2.0
+  module RubyCapabilities
+    # Currently used features
+    # Ruby 3.0+ introduces significant performance improvements
+    RUBY_3_PLUS = (RUBY_VERSION.split('.').map(&:to_i) <=> [3, 0, 0]) >= 0
+
+    # Improved eval performance in Ruby 3.0+
+    # Ruby 3+ has significantly better eval performance than define_method for generated code
+    IMPROVED_EVAL_PERFORMANCE = RUBY_3_PLUS
+
+    # Future optimization opportunities:
+    # RUBY_3_2_PLUS = (RUBY_VERSION.split('.').map(&:to_i) <=> [3, 2, 0]) >= 0
+    # OBJECT_SHAPES_AVAILABLE = RUBY_3_2_PLUS  # Faster ivar access
+    # MN_SCHEDULER_AVAILABLE = RUBY_3_2_PLUS   # Better thread coordination
+    # YJIT_AVAILABLE = RUBY_3_PLUS && !!defined?(RubyVM::YJIT)
+    # IMPROVED_MUTEX_PERFORMANCE = RUBY_3_PLUS
+    # FIBER_SCHEDULER_AVAILABLE = RUBY_3_PLUS && !!defined?(Fiber.set_scheduler)
+
+    # Debug information for troubleshooting (only in development)
+    unless defined?(Rails) && Rails.env.production?
+      def self.report_capabilities
+        {
+          ruby_version: RUBY_VERSION,
+          ruby_3_plus: RUBY_3_PLUS,
+          improved_eval: IMPROVED_EVAL_PERFORMANCE
+        }
+      end
+    end
+  end
+end

data/lib/lazy_init/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LazyInit
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/lazy_init.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'lazy_init/version'
+require_relative 'lazy_init/ruby_capabilities'
 require_relative 'lazy_init/lazy_value'
 require_relative 'lazy_init/class_methods'
 require_relative 'lazy_init/instance_methods'

metadata

@@ -1,85 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: lazy_init
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Konstanty Koszewski
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-06 00:00:00.000000000 Z
+date: 2025-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '2.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '2.10'
 - !ruby/object:Gem::Dependency
-  name: benchmark-ips
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.50.2
+        version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.50.2
+        version: '3.12'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 1.50.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 1.50.2
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0.9'
 description: Provides thread-safe lazy initialization with clean, Ruby-idiomatic API.
   Eliminates race conditions in lazy attribute initialization while maintaining performance.
 email:
@@ -109,6 +109,7 @@ files:
 - lib/lazy_init/errors.rb
 - lib/lazy_init/instance_methods.rb
 - lib/lazy_init/lazy_value.rb
+- lib/lazy_init/ruby_capabilities.rb
 - lib/lazy_init/version.rb
 homepage: https://github.com/N3BCKN/lazy_init
 licenses:
@@ -118,7 +119,7 @@ metadata:
   source_code_uri: https://github.com/N3BCKN/lazy_init
   changelog_uri: https://github.com/N3BCKN/lazy_init/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/N3BCKN/lazy_init/issues
-  documentation_uri: https://rubydoc.info/gems/lazy_init
+  documentation_uri: https://rubydoc.info/gems/lazy_init/0.2.0
 post_install_message:
 rdoc_options: []
 require_paths: