vers 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ad669b5ca951e8a64ddd205d39e083b3a9836a67ca9ff25d99872a57658a560
-  data.tar.gz: d1aefb9f16a5a842ad05d4e427b538a565240cf3c21969542bf614199e8e1955
+  metadata.gz: 13ef83ab41f6ecd9046acb7a33190abc7648805878ffb1c5cf1e3741fa3e7ae5
+  data.tar.gz: 5c8982aeb33abb1e1dec9b17a04693f6dfb7395ec29761680cdd3ca5c85df20e
 SHA512:
-  metadata.gz: 6b87591c17a303bf820c2667f25ac802569173737c8bd63d13c86bc5aedf6e606cc50d3906c08d526dd8c9e934559f0cdc7717e8e6c4cfbd8ae5473ebc53bb9c
-  data.tar.gz: 9a6cafa4929f8a71b699d6ce1171e574bb6c99aca17b89850e7bf232d1269727d00f6a15f1b9a870f8319913e77b0ec865fc5633866161cb989425c9eefc76ce
+  metadata.gz: c5375be69c79738814d42123b157392448603c12c4b5a7f54bde3107bbf12b9f885d08efbe44cddf1c5f2d78b48394eefa73cd720e77928259227a883db273aa
+  data.tar.gz: a6aa16f032331174794e130096751ae08b37cf04ebae8da23ac07a022959ee493c766b98a873908e436d2d69d234623352857b4fd04dce4c71168c6ca4255317

data/Rakefile

@@ -187,74 +187,122 @@ namespace :benchmark do
   task :memory do
     require "benchmark"
     require "json"
+    require "objspace"
     require_relative "lib/vers"
-    
-    puts "💾 VERS Memory Usage Benchmarks"
+
+    puts "VERS Memory & Allocation Benchmarks"
     puts "=" * 50
-    
-    # Load sample ranges
+
     test_data_file = File.join(__dir__, "test-suite-data.json")
-    
+
     unless File.exist?(test_data_file)
-      puts "❌ test-suite-data.json not found. Using fallback examples."
+      puts "test-suite-data.json not found. Using fallback examples."
       sample_ranges = [
-        { input: "^1.2.3", scheme: "npm" },
-        { input: "~> 1.2", scheme: "gem" },
-        { input: ">=1.0,<2.0", scheme: "pypi" }
+        { "input" => "^1.2.3", "scheme" => "npm" },
+        { "input" => "~> 1.2", "scheme" => "gem" },
+        { "input" => ">=1.0,<2.0", "scheme" => "pypi" }
       ]
     else
       test_data = JSON.parse(File.read(test_data_file))
       sample_ranges = test_data.select { |data| !data["is_invalid"] }.first(100)
     end
-    
-    puts "📊 Testing with #{sample_ranges.length} version ranges"
+
+    puts "Sample size: #{sample_ranges.length} version ranges"
     puts
-    
-    # Parse all ranges and store objects
-    puts "🔍 Parsing and storing #{sample_ranges.length} VersionRange objects..."
+
+    # Measure object allocations during cold parsing (no cache)
+    Vers::Version.class_variable_set(:@@version_cache, {})
+    Vers::Constraint.class_variable_set(:@@constraint_cache, {})
+    Vers::Parser.class_variable_set(:@@parser_cache, {})
+
+    GC.start
+    GC.disable
+    before = ObjectSpace.count_objects.dup
+
     version_ranges = []
-    
-    parsing_time = Benchmark.realtime do
-      sample_ranges.each do |range|
-        begin
-          parsed = Vers.parse_native(range['input'], range['scheme'])
-          version_ranges << parsed
-        rescue
-          # Skip invalid ranges
-        end
-      end
+    sample_ranges.each do |range|
+      parsed = Vers.parse_native(range['input'], range['scheme']) rescue nil
+      version_ranges << parsed if parsed
     end
-    
-    puts "   Parsing completed in #{(parsing_time * 1000).round(2)}ms"
-    puts "   Successfully parsed #{version_ranges.length} ranges"
+
+    after = ObjectSpace.count_objects
+    GC.enable
+
+    string_alloc = after[:T_STRING] - before[:T_STRING]
+    array_alloc = after[:T_ARRAY] - before[:T_ARRAY]
+    hash_alloc = after[:T_HASH] - before[:T_HASH]
+    object_alloc = after[:T_OBJECT] - before[:T_OBJECT]
+    match_alloc = (after[:T_MATCH] || 0) - (before[:T_MATCH] || 0)
+    total_alloc = string_alloc + array_alloc + hash_alloc + object_alloc + match_alloc
+
+    puts "Cold parse allocations (#{version_ranges.length} ranges, no cache):"
+    puts "   Total objects:  #{total_alloc}"
+    puts "   Strings:        #{string_alloc}"
+    puts "   Arrays:         #{array_alloc}"
+    puts "   Hashes:         #{hash_alloc}"
+    puts "   Objects:        #{object_alloc}"
+    puts "   MatchData:      #{match_alloc}"
+    puts "   Per range:      #{(total_alloc.to_f / version_ranges.length).round(1)}"
     puts
-    
-    # Estimate memory usage
-    estimated_memory = version_ranges.length * 300  # ~300 bytes per VersionRange object estimate
-    puts "💾 Memory Usage Estimation:"
-    puts "   #{version_ranges.length} VersionRange objects: ~#{estimated_memory} bytes"
-    puts "   Average per object: ~300 bytes"
+
+    # Measure cached parse allocations (everything already cached)
+    GC.start
+    GC.disable
+    before = ObjectSpace.count_objects.dup
+
+    sample_ranges.each do |range|
+      Vers.parse_native(range['input'], range['scheme']) rescue nil
+    end
+
+    after = ObjectSpace.count_objects
+    GC.enable
+
+    cached_strings = after[:T_STRING] - before[:T_STRING]
+    cached_arrays = after[:T_ARRAY] - before[:T_ARRAY]
+    cached_objects = after[:T_OBJECT] - before[:T_OBJECT]
+    cached_match = (after[:T_MATCH] || 0) - (before[:T_MATCH] || 0)
+    cached_alloc = cached_strings + cached_arrays + cached_objects + cached_match
+
+    puts "Cached parse allocations (#{version_ranges.length} ranges, warm cache):"
+    puts "   Total objects:  #{cached_alloc}"
+    puts "   Strings:        #{cached_strings}"
+    puts "   MatchData:      #{cached_match}"
+    puts "   Per range:      #{(cached_alloc.to_f / version_ranges.length).round(1)}"
     puts
-    
-    # Test repeated operations
-    puts "🔄 Repeated Operations Test:"
-    
+
+    # Measure memory size of retained objects
+    total_memsize = version_ranges.sum { |r| ObjectSpace.memsize_of(r) }
+    puts "Retained memory:"
+    puts "   #{version_ranges.length} VersionRange objects: #{total_memsize} bytes"
+    puts "   Average per object: #{(total_memsize.to_f / version_ranges.length).round(0)} bytes"
+    puts
+
+    # Repeated operation allocations
+    puts "Repeated operation allocations (#{version_ranges.length} calls each):"
+
     operations = {
-      "to_s conversion" => proc { version_ranges.each(&:to_s) },
-      "contains? check" => proc { version_ranges.each { |r| r.contains?("1.5.0") } },
-      "empty? check" => proc { version_ranges.each(&:empty?) },
-      "unbounded? check" => proc { version_ranges.each(&:unbounded?) }
+      "to_s" => proc { version_ranges.each(&:to_s) },
+      "contains?" => proc { version_ranges.each { |r| r.contains?("1.5.0") } },
+      "empty?" => proc { version_ranges.each(&:empty?) },
     }
-    
-    operations.each do |op_name, op_proc|
-      time = Benchmark.realtime { op_proc.call }
-      ops_per_second = version_ranges.length / time
-      
-      puts "   #{op_name.ljust(20)}: #{(time * 1000).round(2)}ms (#{ops_per_second.round(0)} ops/sec)"
+
+    operations.each do |name, op|
+      # Warm up
+      op.call
+
+      GC.start
+      GC.disable
+      before = ObjectSpace.count_objects.dup
+      op.call
+      after = ObjectSpace.count_objects
+      GC.enable
+
+      allocs = [:T_STRING, :T_ARRAY, :T_OBJECT, :T_MATCH, :T_HASH].sum { |k| (after[k] || 0) - (before[k] || 0) }
+      puts "   #{name.ljust(15)}: #{allocs} allocations"
     end
-    
+
     puts
-    puts "✅ Memory benchmark completed!"
+    puts "Memory benchmark completed!"
   end
   
   desc "Run complexity stress tests"

data/lib/vers/constraint.rb

@@ -23,7 +23,7 @@ module Vers
     
     # Cache for parsed constraints
     @@constraint_cache = {}
-    @@cache_size_limit = 500
+    @@cache_size_limit = 1000
 
     attr_reader :operator, :version
 
@@ -54,14 +54,13 @@ module Vers
     #   Vers::Constraint.parse("!=2.0.0")  # => #<Vers::Constraint:0x... @operator="!=", @version="2.0.0">
     #
     def self.parse(constraint_string)
-      # Limit cache size to prevent memory bloat
+      return @@constraint_cache[constraint_string] if @@constraint_cache.key?(constraint_string)
+
       if @@constraint_cache.size >= @@cache_size_limit
-        @@constraint_cache.clear
+        keys = @@constraint_cache.keys
+        keys.first(keys.size / 2).each { |k| @@constraint_cache.delete(k) }
       end
-      
-      # Return cached constraint if available
-      return @@constraint_cache[constraint_string] if @@constraint_cache.key?(constraint_string)
-      
+
       constraint = parse_uncached(constraint_string)
       @@constraint_cache[constraint_string] = constraint
       constraint

data/lib/vers/interval.rb

@@ -12,8 +12,7 @@ module Vers
       @min_inclusive = min_inclusive
       @max_inclusive = max_inclusive
       @scheme = scheme
-
-      validate_bounds!
+      @empty = compute_empty
     end
 
     def self.empty(scheme: nil)
@@ -37,9 +36,7 @@ module Vers
     end
 
     def empty?
-      return true if min && max && version_compare(min, max) > 0
-      return true if min && max && version_compare(min, max) == 0 && (!min_inclusive || !max_inclusive)
-      false
+      @empty
     end
 
     def unbounded?
@@ -180,7 +177,22 @@ module Vers
 
     def overlaps?(other)
       return false if empty? || other.empty?
-      !intersect(other).empty?
+      return true if unbounded? || other.unbounded?
+
+      # Check if the intervals can't overlap by comparing bounds directly
+      if max && other.min
+        cmp = version_compare(max, other.min)
+        return false if cmp < 0
+        return false if cmp == 0 && (!max_inclusive || !other.min_inclusive)
+      end
+
+      if min && other.max
+        cmp = version_compare(min, other.max)
+        return false if cmp > 0
+        return false if cmp == 0 && (!min_inclusive || !other.max_inclusive)
+      end
+
+      true
     end
 
     def adjacent?(other)
@@ -211,14 +223,12 @@ module Vers
 
     private
 
-    def validate_bounds!
-      return unless min && max
-      
-      comparison = version_compare(min, max)
-      if comparison > 0
-        return
-      elsif comparison == 0 && (!min_inclusive || !max_inclusive)
-        return
+    def compute_empty
+      if min && max
+        cmp = version_compare(min, max)
+        cmp > 0 || (cmp == 0 && (!min_inclusive || !max_inclusive))
+      else
+        false
       end
     end
 

data/lib/vers/parser.rb

@@ -26,10 +26,11 @@ module Vers
     NPM_HYPHEN_REGEX = /\A(.+?)\s+-\s+(.+)\z/
     NPM_X_RANGE_MAJOR_REGEX = /\A(\d+)\.x\z/
     NPM_X_RANGE_MINOR_REGEX = /\A(\d+)\.(\d+)\.x\z/
+    OPERATOR_PREFIX_REGEX = /\A[><=!]+/
     
     # Cache for parsed ranges to improve performance
     @@parser_cache = {}
-    @@cache_size_limit = 200
+    @@cache_size_limit = 500
 
     ##
     # Parses a vers URI string into a VersionRange
@@ -151,7 +152,7 @@ module Vers
     private
 
     def sort_key_for_constraint(constraint)
-      version = constraint.sub(/\A[><=!]+/, '')
+      version = constraint.sub(OPERATOR_PREFIX_REGEX, '')
       v = Version.cached_new(version)
       [v, constraint]
     end
@@ -231,15 +232,12 @@ module Vers
     end
 
     def parse_npm_single_range(range_string)
-      # Check cache first
       cache_key = "npm:#{range_string}"
-      if @@parser_cache.key?(cache_key)
-        return @@parser_cache[cache_key]
-      end
-      
-      # Limit cache size
+      return @@parser_cache[cache_key] if @@parser_cache.key?(cache_key)
+
       if @@parser_cache.size >= @@cache_size_limit
-        @@parser_cache.clear
+        keys = @@parser_cache.keys
+        keys.first(keys.size / 2).each { |k| @@parser_cache.delete(k) }
       end
       
       result = case range_string

data/lib/vers/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Vers
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 
   ##
   # Handles version comparison and normalization across different package ecosystems.
@@ -18,7 +18,7 @@ module Vers
   class Version
     # Cache for parsed versions to avoid repeated parsing
     @@version_cache = {}
-    @@cache_size_limit = 1000
+    @@cache_size_limit = 2000
     # Regex for parsing semantic version components including build metadata
     SEMANTIC_VERSION_REGEX = /\A(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([^+]+))?(?:\+(.+))?\z/
 
@@ -41,11 +41,12 @@ module Vers
     # @return [Version] Cached or new Version object
     #
     def self.cached_new(version_string)
-      # Limit cache size to prevent memory bloat
       if @@version_cache.size >= @@cache_size_limit
-        @@version_cache.clear
+        # Keep the most recent half instead of clearing everything
+        keys = @@version_cache.keys
+        keys.first(keys.size / 2).each { |k| @@version_cache.delete(k) }
       end
-      
+
       @@version_cache[version_string] ||= new(version_string)
     end
 
@@ -145,15 +146,17 @@ module Vers
     # @return [String] The normalized version string
     #
     def to_s
-      version = "#{major || 0}"
-      version += ".#{minor || 0}"
-      version += ".#{patch || 0}"
-      version += "-#{prerelease}" if prerelease
-      version
+      @to_s ||= begin
+        version = "#{major || 0}"
+        version += ".#{minor || 0}"
+        version += ".#{patch || 0}"
+        version += "-#{prerelease}" if prerelease
+        version.freeze
+      end
     end
 
     def ==(other)
-      other.is_a?(Version) && self <=> other == 0
+      other.is_a?(Version) && (self <=> other) == 0
     end
 
     def <(other)
@@ -320,7 +323,7 @@ module Vers
       @original = @original.sub(/\Av/i, '')
 
       # Handle simple numeric versions (optimized case)
-      if @original.match(/^\d+$/)
+      if @original.match?(/^\d+$/)
         @major = @original.to_i
         return
       end
@@ -382,7 +385,7 @@ module Vers
         return 1 if part_b.nil?
         
         # Try numeric comparison first
-        if part_a.match(/^\d+$/) && part_b.match(/^\d+$/)
+        if part_a.match?(/^\d+$/) && part_b.match?(/^\d+$/)
           numeric_cmp = part_a.to_i <=> part_b.to_i
           return numeric_cmp unless numeric_cmp == 0
         else

data/lib/vers/version_range.rb

@@ -9,7 +9,7 @@ module Vers
 
     def initialize(intervals = [], raw_constraints: nil, scheme: nil)
       @scheme = scheme
-      @intervals = intervals.compact.reject(&:empty?)
+      @intervals = intervals.select { |i| i && !i.empty? }
       if @scheme
         @intervals.sort! { |a, b| compare_interval_bounds(a, b) }
       else

data/lib/vers.rb

@@ -126,7 +126,7 @@ module Vers
               else
                 parse(sub_range)
               end
-      range.contains?(version)
+      range&.contains?(version) || false
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vers
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Andrew Nesbitt