123456789_123456789_123456789_123456789_123456789_

Exception: Gem::Resolver::Molinillo::VersionConflict

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ResolverError, StandardError
Instance Chain:
self, Delegates::SpecificationProvider, ResolverError, StandardError
Inherits: Gem::Resolver::Molinillo::ResolverError
Defined in: lib/rubygems/resolver/molinillo/lib/molinillo/errors.rb

Overview

An error caused by conflicts in version

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Delegates::SpecificationProvider - Included

#allow_missing?

Returns whether this dependency, which has no possible matching specifications, can safely be ignored.
#dependencies_equal?

Determines whether two arrays of dependencies are equal, and thus can be grouped.
#dependencies_for

Returns the dependencies of specification.
#name_for

Returns the name for the given dependency.
#name_for_explicit_dependency_source, #name_for_locking_dependency_source,
#requirement_satisfied_by?

Determines whether the given requirement is satisfied by the given spec, in the context of the current activated dependency graph.
#search_for

Search for the specifications that match the given dependency.
#sort_dependencies

Sort dependencies so that the ones that are easiest to resolve are first.
#with_no_such_dependency_error_handling

Ensures any raised NoSuchDependencyError has its NoSuchDependencyError#required_by set.

Constructor Details

.new(conflicts, specification_provider) ⇒ VersionConflict

Initializes a new error with the given version conflicts.

Parameters:

[ GitHub ] 

  


# File 'lib/rubygems/resolver/molinillo/lib/molinillo/errors.rb', line 66



def initialize(conflicts, specification_provider)
  pairs = []
  conflicts.values.flat_map(&:requirements).each do |conflicting|
    conflicting.each do |source, conflict_requirements|
      conflict_requirements.each do |c|
        pairs << [c, source]
      end
    end
  end

  super "Unable to satisfy the following requirements:\n\n" \
    "#{pairs.map { |r, d| "- `#{r}` required by `#{d}`" }.join("\n")}"

  @conflicts = conflicts
  @specification_provider = specification_provider
end


  







Instance Attribute Details



  

    #conflicts  ⇒ {String => Resolution::Conflict}  (readonly)
  



  

    
  





  
Returns:


    
  
  • 
    ({String => Resolution::Conflict})
—    
    

    the conflicts that caused resolution to fail
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/rubygems/resolver/molinillo/lib/molinillo/errors.rb', line 57



attr_reader :conflicts


  








  

    #specification_provider  ⇒ SpecificationProvider  (readonly)
  



  

    
  





  
Returns:





  [ GitHub ]


  

  


# File 'lib/rubygems/resolver/molinillo/lib/molinillo/errors.rb', line 61



attr_reader :specification_provider


  







Instance Method Details



  

    #message_with_trees(opts = {})  ⇒ String 
  



  

    
  





  
Parameters:


    
  
  • 
    opts
    (Hash)
    (defaults to: {})
—    
    

    the options to create a message with.
    

    
  
    • 


    
Options Hash (opts):

    
    
        
  • 
          :solver_name
          (String)
            — 
    

    The user-facing name of the solver
    

            
    • 
        
  • 
          :possibility_type
          (String)
            — 
    

    The generic name of a possibility
    

            
    • 
        
  • 
          :reduce_trees
          (Proc)
            — 
    

    A proc that reduced the list of requirement trees
    

            
    • 
        
  • 
          :printable_requirement
          (Proc)
            — 
    

    A proc that pretty-prints requirements
    

            
    • 
        
  • 
          :additional_message_for_conflict
          (Proc)
            — 
    

    A proc that appends additional messages for each conflict
    

            
    • 
        
  • 
          :version_for_spec
          (Proc)
            — 
    

    A proc that returns the version number for a possibility
    

            
    • 
    


Returns:


    
  
  • 
    (String)
—    
    

    An error message that includes requirement trees, which is much more detailed & customizable than the default message
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/rubygems/resolver/molinillo/lib/molinillo/errors.rb', line 97



def message_with_trees(opts = {})
  solver_name = opts.delete(:solver_name) { self.class.name.split('::').first }
  possibility_type = opts.delete(:possibility_type) { 'possibility named' }
  reduce_trees = opts.delete(:reduce_trees) { proc { |trees| trees.uniq.sort_by(&:to_s) } }
  printable_requirement = opts.delete(:printable_requirement) { proc { |req| req.to_s } }
  additional_message_for_conflict = opts.delete(:additional_message_for_conflict) { proc {} }
  version_for_spec = opts.delete(:version_for_spec) { proc(&:to_s) }
  incompatible_version_message_for_conflict = opts.delete(:incompatible_version_message_for_conflict) do
    proc do |name, _conflict|
      %(#{solver_name} could not find compatible versions for #{possibility_type} "#{name}":)
    end
  end

  full_message_for_conflict = opts.delete(:full_message_for_conflict) do
    proc do |name, conflict|
      o = "\n".dup << incompatible_version_message_for_conflict.call(name, conflict) << "\n"
      if conflict.locked_requirement
        o << %(  In snapshot (#{name_for_locking_dependency_source}):\n)
        o << %(    #{printable_requirement.call(conflict.locked_requirement)}\n)
        o << %(\n)
      end
      o << %(  In #{name_for_explicit_dependency_source}:\n)
      trees = reduce_trees.call(conflict.requirement_trees)

      o << trees.map do |tree|
        t = ''.dup
        depth = 2
        tree.each do |req|
          t << '  ' * depth << printable_requirement.call(req)
          unless tree.last == req
            if spec = conflict.activated_by_name[name_for(req)]
              t << %( was resolved to #{version_for_spec.call(spec)}, which)
            end
            t << %( depends on)
          end
          t << %(\n)
          depth += 1
        end
        t
      end.join("\n")

      additional_message_for_conflict.call(o, name, conflict)

      o
    end
  end

  conflicts.sort.reduce(''.dup) do |o, (name, conflict)|
    o << full_message_for_conflict.call(name, conflict)
  end.strip
end