Class: Kettle::Jem::Appraisals::GemVersionResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/kettle/jem/appraisals/gem_version_resolver.rb,
sig/kettle/jem/appraisals.rbs

Overview

Adapter over Kettle/Jem's shared RubyGems resolver.

Kettle/Jem owns the RubyGems HTTP/cache/minimum-Ruby behavior because Gemfile, gemspec, and appraisal planning need the same package metadata. This class preserves the appraisals-local type name while delegating the implementation to RubyGemsResolver.

Examples:

Fetch all stable versions of a gem

resolver = GemVersionResolver.new
resolver.versions("activerecord")
#=> [{number: "7.1.3", ruby_version: ">= 2.7.0", ...}, ...]

Constant Summary collapse

RUBYGEMS_API_BASE =

Returns:

  • (String) 

      
        
RUBYGEMS_V2_API_BASE =
          

  

    

  





  

Returns:


    
  
    
  • 
      
      
        (String)
      
      
      
    
    • 
  





        

        

      
    

  




  
Instance Attribute Summary collapse

  




  
    

      Instance Method Summary
      collapse
    


    
    
  



  
Constructor Details

  
    

  

  
    #initialize(resolver: nil, **resolver_options)  ⇒ GemVersionResolver 
  

  

  


  

    
Returns a new instance of GemVersionResolver.


  





  
Parameters:


    
  
    
  • 
      
        resolver
      
      
        (Kettle::Jem::RubyGemsResolver, nil)
      
      
        (defaults to: nil)
      
      
        —
        
    optional pre-built resolver for sharing a warm cache across multiple
appraisals components in the same session
    
      
    
    • 
  






  

    
      


29
30
31

    		
    
      
# File 'lib/kettle/jem/appraisals/gem_version_resolver.rb', line 29

def initialize(resolver: nil, **resolver_options)
  @resolver = resolver || Kettle::Jem::RubyGemsResolver.new(**resolver_options)
end

    		
  





  



  

    
Instance Attribute Details

    
      
      
      

  

  
    #cache  ⇒ Hash  (readonly)
  

  

  


  

    
Returns in-memory cache of API responses.


  





  

Returns:


    
  
    
  • 
      
      
        (Hash)
      
      
      
        —
        
    in-memory cache of API responses
    
      
    
    • 
  





  

    
      


22
23
24

    		
    
      
# File 'lib/kettle/jem/appraisals/gem_version_resolver.rb', line 22

def cache
  resolver.cache
end

    		
  





    
      
      
      

  

  
    #resolver  ⇒ Kettle::Jem::RubyGemsResolver  (readonly)
  

  

  


  

    
Returns shared Kettle/Jem resolver.


  





  

Returns:


    
  
    
  • 
      
      
        (Kettle::Jem::RubyGemsResolver)
      
      
      
        —
        
    shared Kettle/Jem resolver
    
      
    
    • 
  





  

    
      


19
20
21

    		
    
      
# File 'lib/kettle/jem/appraisals/gem_version_resolver.rb', line 19

def resolver
  @resolver
end

    		
  





    
  



  

    
Instance Method Details


    
      

  

  
    #fetch_gem_info  ⇒ Hash[String, untyped]? 
  

  

  


  

    

  





  
Parameters:


    
  
    
  • 
      
        gem_name
      
      
        (String)
      
      
      
    
    • 
  
    
  • 
      
        version
      
      
        (String)
      
      
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (Hash[String, untyped], nil)
      
      
      
    
    • 
  





  

    
      


77

    		
    
      
# File 'sig/kettle/jem/appraisals.rbs', line 77

def fetch_gem_info: (String gem_name, String version) -> Hash[String, untyped]?

    		
  





    
      

  

  
    #fetch_versions  ⇒ Array[Hash[String, untyped]] 
  

  

  


  

    

  





  
Parameters:


    
  
    
  • 
      
        gem_name
      
      
        (String)
      
      
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (Array[Hash[String, untyped]])
      
      
      
    
    • 
  





  

    
      


76

    		
    
      
# File 'sig/kettle/jem/appraisals.rbs', line 76

def fetch_versions: (String gem_name) -> Array[Hash[String, untyped]]

    		
  





    
      

  

  
    #min_ruby_version(gem_name, version)  ⇒ Gem::Version? 
  

  

  


  

    
Returns the minimum Ruby version required by a specific gem version.


Delegates to RubyGemsResolver#min_ruby_version.


  





  
Parameters:


    
  
    
  • 
      
        gem_name
      
      
        (String)
      
      
      
        —
        
    the RubyGems gem name
    
      
    
    • 
  
    
  • 
      
        version
      
      
        (String)
      
      
      
        —
        
    an exact version string (e.g., "7.1.3")
    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (Gem::Version, nil)
      
      
      
        —
        
    the minimum required Ruby version, or nil if unspecified
    
      
    
    • 
  





  

    
      


64
65
66

    		
    
      
# File 'lib/kettle/jem/appraisals/gem_version_resolver.rb', line 64

def min_ruby_version(gem_name, version)
  resolver.min_ruby_version(gem_name, version)
end

    		
  





    
      

  

  
    #minor_versions_by_major(gem_name, requirements: nil)  ⇒ Array<Hash> 
  

  

  


  

    
Returns all minor versions (+X.Y+) for a gem, grouped by major version.


  





  
  

    
Examples:

    
      
      
resolver.minor_versions_by_major("activerecord")
#=> [{major: 6, minors: ["6.0", "6.1"]}, {major: 7, minors: ["7.0", "7.1", "7.2"]}]

    
  


Parameters:


    
  
    
  • 
      
        gem_name
      
      
        (String)
      
      
      
        —
        
    the RubyGems gem name
    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (Array<Hash>)
      
      
      
        —
        
    sorted entries, each with :major (Integer) and :minors (Array)
    
      
    
    • 
  





  

    
      


75
76
77

    		
    
      
# File 'lib/kettle/jem/appraisals/gem_version_resolver.rb', line 75

def minor_versions_by_major(gem_name, requirements: nil)
  resolver.minor_versions_by_major(gem_name, requirements: requirements)
end

    		
  





    
      

  

  
    #parse_min_ruby  ⇒ Gem::Version? 
  

  

  


  

    

  





  
Parameters:


    
  
    
  • 
      
        requirement_str
      
      
        (String, nil)
      
      
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (Gem::Version, nil)
      
      
      
    
    • 
  





  

    
      


78

    		
    
      
# File 'sig/kettle/jem/appraisals.rbs', line 78

def parse_min_ruby: (String? requirement_str) -> Gem::Version?

    		
  





    
      

  

  
    #version_info(gem_name, version)  ⇒ Hash? 
  

  

  


  

    
Returns version info (dependencies, ruby_version) for a specific gem version.


Uses the v2 API which includes the full dependency structure.


  





  
Parameters:


    
  
    
  • 
      
        gem_name
      
      
        (String)
      
      
      
        —
        
    the RubyGems gem name
    
      
    
    • 
  
    
  • 
      
        version
      
      
        (String)
      
      
      
        —
        
    an exact version string (e.g., "7.1.3")
    
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (Hash, nil)
      
      
      
        —
        
    a Hash with :number, :ruby_version, and :runtime_dependencies,
or nil if the version was not found
    
      
    
    • 
  





  

    
      


53
54
55

    		
    
      
# File 'lib/kettle/jem/appraisals/gem_version_resolver.rb', line 53

def version_info(gem_name, version)
  resolver.version_info(gem_name, version)
end

    		
  





    
      

  

  
    #versions(gem_name, include_prerelease: false, requirements: nil)  ⇒ Array<Hash> 
  

  

  


  

    
Returns all versions of a gem, sorted oldest-to-newest.


Each entry is a Hash with the keys :number, :ruby_version,
:created_at, and :prerelease.


  





  
Parameters:


    
  
    
  • 
      
        gem_name
      
      
        (String)
      
      
      
        —
        
    the RubyGems gem name
    
      
    
    • 
  
    
  • 
      
        include_prerelease
      
      
        (Boolean)
      
      
        (defaults to: false)
      
      
        —
        
    when true, includes pre-release versions (default: false)
    
      
    
    • 
  
    
  • 
      
        include_prerelease:
      
      
        (Boolean)
      
      
        (defaults to: false)
      
      
    
    • 
  




Returns:


    
  
    
  • 
      
      
        (Array<Hash>)
      
      
      
        —
        
    version hashes sorted by Gem::Version
    
      
    
    • 
  





  

    
      


41
42
43

    		
    
      
# File 'lib/kettle/jem/appraisals/gem_version_resolver.rb', line 41

def versions(gem_name, include_prerelease: false, requirements: nil)
  resolver.versions(gem_name, include_prerelease: include_prerelease, requirements: requirements)
end