Gecko [ primetaxinc.net ]

Name	Size	Permission
commands	[ DIR ]	drwxr-xr-x
core_ext	[ DIR ]	drwxr-xr-x
ext	[ DIR ]	drwxr-xr-x
package	[ DIR ]	drwxr-xr-x
request	[ DIR ]	drwxr-xr-x
request_set	[ DIR ]	drwxr-xr-x
resolver	[ DIR ]	drwxr-xr-x
security	[ DIR ]	drwxr-xr-x
source	[ DIR ]	drwxr-xr-x
ssl_certs	[ DIR ]	drwxr-xr-x
util	[ DIR ]	drwxr-xr-x
available_set.rb	2.99 KB	-rw-r--r--
basic_specification.rb	6.66 KB	-rw-r--r--
command.rb	13.55 KB	-rw-r--r--
command_manager.rb	4.63 KB	-rw-r--r--
compatibility.rb	1.63 KB	-rw-r--r--
config_file.rb	12.57 KB	-rw-r--r--
defaults.rb	4.01 KB	-rw-r--r--
dependency.rb	8.48 KB	-rw-r--r--
dependency_installer.rb	13.81 KB	-rw-r--r--
dependency_list.rb	5.44 KB	-rw-r--r--
deprecate.rb	1.7 KB	-rw-r--r--
doctor.rb	3.04 KB	-rw-r--r--
errors.rb	3.12 KB	-rw-r--r--
exceptions.rb	6.2 KB	-rw-r--r--
ext.rb	431 B	-rw-r--r--
gem_runner.rb	1.96 KB	-rw-r--r--
gemcutter_utilities.rb	3.94 KB	-rw-r--r--
indexer.rb	13.03 KB	-rw-r--r--
install_default_message.rb	307 B	-rw-r--r--
install_message.rb	281 B	-rw-r--r--
install_update_options.rb	5.85 KB	-rw-r--r--
installer.rb	22.48 KB	-rw-r--r--
installer_test_case.rb	4.23 KB	-rw-r--r--
local_remote_options.rb	3.37 KB	-rw-r--r--
mock_gem_ui.rb	1.35 KB	-rw-r--r--
name_tuple.rb	2.37 KB	-rw-r--r--
package.rb	14.87 KB	-rw-r--r--
package_task.rb	3.77 KB	-rw-r--r--
path_support.rb	1.82 KB	-rw-r--r--
platform.rb	6.13 KB	-rw-r--r--
psych_additions.rb	269 B	-rw-r--r--
psych_tree.rb	763 B	-rw-r--r--
rdoc.rb	7.71 KB	-rw-r--r--
remote_fetcher.rb	11.09 KB	-rw-r--r--
request.rb	6.73 KB	-rw-r--r--
request_set.rb	9.4 KB	-rw-r--r--
requirement.rb	6.2 KB	-rw-r--r--
resolver.rb	13.35 KB	-rw-r--r--
safe_yaml.rb	1.11 KB	-rw-r--r--
security.rb	20.96 KB	-rw-r--r--
server.rb	22.93 KB	-rw-r--r--
source.rb	5.21 KB	-rw-r--r--
source_list.rb	2.47 KB	-rw-r--r--
source_local.rb	111 B	-rw-r--r--
source_specific_file.rb	93 B	-rw-r--r--
spec_fetcher.rb	6.31 KB	-rw-r--r--
specification.rb	72.88 KB	-rw-r--r--
stub_specification.rb	3.56 KB	-rw-r--r--
syck_hack.rb	2.09 KB	-rw-r--r--
test_case.rb	37.49 KB	-rw-r--r--
test_utilities.rb	8.44 KB	-rw-r--r--
text.rb	1.9 KB	-rw-r--r--
uninstaller.rb	8.72 KB	-rw-r--r--
uri_formatter.rb	762 B	-rw-r--r--
user_interaction.rb	14.64 KB	-rw-r--r--
util.rb	2.59 KB	-rw-r--r--
validator.rb	4.18 KB	-rw-r--r--
version.rb	10.92 KB	-rw-r--r--
version_option.rb	1.83 KB	-rw-r--r--

Code Editor : resolver.rb

require 'rubygems/dependency'
require 'rubygems/exceptions'
require 'rubygems/util/list'

require 'uri'
require 'net/http'

##
# Given a set of Gem::Dependency objects as +needed+ and a way to query the
# set of available specs via +set+, calculates a set of ActivationRequest
# objects which indicate all the specs that should be activated to meet the
# all the requirements.

class Gem::Resolver

##
  # If the DEBUG_RESOLVER environment variable is set then debugging mode is
  # enabled for the resolver.  This will display information about the state
  # of the resolver while a set of dependencies is being resolved.

DEBUG_RESOLVER = !ENV['DEBUG_RESOLVER'].nil?

require 'pp' if DEBUG_RESOLVER

##
  # Contains all the conflicts encountered while doing resolution

attr_reader :conflicts

##
  # Set to true if all development dependencies should be considered.

attr_accessor :development

##
  # Set to true if immediate development dependencies should be considered.

attr_accessor :development_shallow

##
  # When true, no dependencies are looked up for requested gems.

attr_accessor :ignore_dependencies

##
  # List of dependencies that could not be found in the configured sources.

attr_reader :missing

attr_reader :stats

##
  # Hash of gems to skip resolution.  Keyed by gem name, with arrays of
  # gem specifications as values.

attr_accessor :skip_gems

##
  # When a missing dependency, don't stop. Just go on and record what was
  # missing.

attr_accessor :soft_missing

##
  # Combines +sets+ into a ComposedSet that allows specification lookup in a
  # uniform manner.  If one of the +sets+ is itself a ComposedSet its sets are
  # flattened into the result ComposedSet.

def self.compose_sets *sets
    sets.compact!

sets = sets.map do |set|
      case set
      when Gem::Resolver::BestSet then
        set
      when Gem::Resolver::ComposedSet then
        set.sets
      else
        set
      end
    end.flatten

case sets.length
    when 0 then
      raise ArgumentError, 'one set in the composition must be non-nil'
    when 1 then
      sets.first
    else
      Gem::Resolver::ComposedSet.new(*sets)
    end
  end

##
  # Creates a Resolver that queries only against the already installed gems
  # for the +needed+ dependencies.

def self.for_current_gems needed
    new needed, Gem::Resolver::CurrentSet.new
  end

##
  # Create Resolver object which will resolve the tree starting
  # with +needed+ Dependency objects.
  #
  # +set+ is an object that provides where to look for specifications to
  # satisfy the Dependencies. This defaults to IndexSet, which will query
  # rubygems.org.

def initialize needed, set = nil
    @set = set || Gem::Resolver::IndexSet.new
    @needed = needed

@conflicts           = []
    @development         = false
    @development_shallow = false
    @ignore_dependencies = false
    @missing             = []
    @skip_gems           = {}
    @soft_missing        = false
    @stats               = Gem::Resolver::Stats.new
  end

def explain stage, *data # :nodoc:
    return unless DEBUG_RESOLVER

d = data.map { |x| x.pretty_inspect }.join(", ")
    $stderr.printf "%10s %s\n", stage.to_s.upcase, d
  end

def explain_list stage # :nodoc:
    return unless DEBUG_RESOLVER

data = yield
    $stderr.printf "%10s (%d entries)\n", stage.to_s.upcase, data.size
    PP.pp data, $stderr unless data.empty?
  end

##
  # Creates an ActivationRequest for the given +dep+ and the last +possible+
  # specification.
  #
  # Returns the Specification and the ActivationRequest

def activation_request dep, possible # :nodoc:
    spec = possible.pop

explain :activate, [spec.full_name, possible.size]
    explain :possible, possible

activation_request =
      Gem::Resolver::ActivationRequest.new spec, dep, possible

return spec, activation_request
  end

def requests s, act, reqs=nil # :nodoc:
    return reqs if @ignore_dependencies

s.fetch_development_dependencies if @development

s.dependencies.reverse_each do |d|
      next if d.type == :development and not @development
      next if d.type == :development and @development_shallow and
              act.development?
      next if d.type == :development and @development_shallow and
              act.parent

reqs.add Gem::Resolver::DependencyRequest.new(d, act)
      @stats.requirement!
    end

@set.prefetch reqs

@stats.record_requirements reqs

reqs
  end

##
  # Proceed with resolution! Returns an array of ActivationRequest objects.

def resolve
    @conflicts = []

needed = Gem::Resolver::RequirementList.new

@needed.reverse_each do |n|
      request = Gem::Resolver::DependencyRequest.new n, nil

needed.add request
      @stats.requirement!
    end

@stats.record_requirements needed

res = resolve_for needed, nil

raise Gem::DependencyResolutionError, res if
      res.kind_of? Gem::Resolver::Conflict

res.to_a
  end

##
  # Extracts the specifications that may be able to fulfill +dependency+ and
  # returns those that match the local platform and all those that match.

def find_possible dependency # :nodoc:
    all = @set.find_all dependency

if (skip_dep_gems = skip_gems[dependency.name]) && !skip_dep_gems.empty?
      matching = all.select do |api_spec|
        skip_dep_gems.any? { |s| api_spec.version == s.version }
      end

all = matching unless matching.empty?
    end

matching_platform = select_local_platforms all

return matching_platform, all
  end

def handle_conflict(dep, existing) # :nodoc:
    # There is a conflict! We return the conflict object which will be seen by
    # the caller and be handled at the right level.

# If the existing activation indicates that there are other possibles for
    # it, then issue the conflict on the dependency for the activation itself.
    # Otherwise, if there was a requester, issue it on the requester's
    # request itself.
    # Finally, if the existing request has no requester (toplevel) unwind to
    # it anyway.

if existing.others_possible?
      conflict =
        Gem::Resolver::Conflict.new dep, existing
    elsif dep.requester
      depreq = dep.requester.request
      conflict =
        Gem::Resolver::Conflict.new depreq, existing, dep
    elsif existing.request.requester.nil?
      conflict =
        Gem::Resolver::Conflict.new dep, existing
    else
      raise Gem::DependencyError, "Unable to figure out how to unwind conflict"
    end

@conflicts << conflict unless @conflicts.include? conflict

return conflict
  end

# Contains the state for attempting activation of a set of possible specs.
  # +needed+ is a Gem::List of DependencyRequest objects that, well, need
  # to be satisfied.
  # +specs+ is the List of ActivationRequest that are being tested.
  # +dep+ is the DependencyRequest that was used to generate this state.
  # +spec+ is the Specification for this state.
  # +possible+ is List of DependencyRequest objects that can be tried to
  # find a  complete set.
  # +conflicts+ is a [DependencyRequest, Conflict] hit tried to
  # activate the state.
  #
  State = Struct.new(:needed, :specs, :dep, :spec, :possibles, :conflicts) do
    def summary # :nodoc:
      nd = needed.map { |s| s.to_s }.sort if nd

if specs then
        ss = specs.map { |s| s.full_name }.sort
        ss.unshift ss.length
      end

d = dep.to_s
      d << " from #{dep.requester.full_name}" if dep.requester

ps = possibles.map { |p| p.full_name }.sort
      ps.unshift ps.length

cs = conflicts.map do |(s, c)|
        [s.full_name, c.conflicting_dependencies.map { |cd| cd.to_s }]
      end

{ :needed => nd, :specs => ss, :dep => d, :spec => spec.full_name,
        :possibles => ps, :conflicts => cs }
    end
  end

##
  # The meat of the algorithm. Given +needed+ DependencyRequest objects and
  # +specs+ being a list to ActivationRequest, calculate a new list of
  # ActivationRequest objects.

def resolve_for needed, specs # :nodoc:
    # The State objects that are used to attempt the activation tree.
    states = []

while !needed.empty?
      @stats.iteration!

dep = needed.remove
      explain :try, [dep, dep.requester ? dep.requester.request : :toplevel]
      explain_list(:next5) { needed.next5 }
      explain_list(:specs) { Array(specs).map { |x| x.full_name }.sort }

# If there is already a spec activated for the requested name...
      if specs && existing = specs.find { |s| dep.name == s.name }
        # then we're done since this new dep matches the existing spec.
        next if dep.matches_spec? existing

conflict = handle_conflict dep, existing

return conflict unless dep.requester

explain :conflict, dep, :existing, existing.full_name

depreq = dep.requester.request

state = nil
        until states.empty?
          x = states.pop

i = existing.request.requester
          explain :consider, x.spec.full_name, [depreq.name, dep.name, i ? i.name : :top]

if x.spec.name == depreq.name or
              x.spec.name == dep.name or
              (i && (i.name == x.spec.name))
            explain :found, x.spec.full_name
            state = x
            break
          end
        end

return conflict unless state

@stats.backtracking!

needed, specs = resolve_for_conflict needed, specs, state

states << state unless state.possibles.empty?

next
      end

matching, all = find_possible dep

case matching.size
      when 0
        resolve_for_zero dep, all
      when 1
        needed, specs =
          resolve_for_single needed, specs, dep, matching
      else
        needed, specs =
          resolve_for_multiple needed, specs, states, dep, matching
      end
    end

specs
  end

##
  # Rewinds +needed+ and +specs+ to a previous state in +state+ for a conflict
  # between +dep+ and +existing+.

def resolve_for_conflict needed, specs, state # :nodoc:
    # We exhausted the possibles so it's definitely not going to work out,
    # bail out.
    raise Gem::ImpossibleDependenciesError.new state.dep, state.conflicts if
      state.possibles.empty?

# Retry resolution with this spec and add it's dependencies
    spec, act = activation_request state.dep, state.possibles

needed = requests spec, act, state.needed.dup
    specs = Gem::List.prepend state.specs, act

return needed, specs
  end

##
  # There are multiple +possible+ specifications for this +dep+.  Updates
  # +needed+, +specs+ and +states+ for further resolution of the +possible+
  # choices.

def resolve_for_multiple needed, specs, states, dep, possible # :nodoc:
    # Sort them so that we try the highest versions first.
    possible = possible.sort_by do |s|
      [s.source, s.version, s.platform == Gem::Platform::RUBY ? -1 : 1]
    end

spec, act = activation_request dep, possible

# We may need to try all of +possible+, so we setup state to unwind back
    # to current +needed+ and +specs+ so we can try another. This is code is
    # what makes conflict resolution possible.
    states << State.new(needed.dup, specs, dep, spec, possible, [])

@stats.record_depth states

explain :states, states.map { |s| s.dep }

needed = requests spec, act, needed
    specs = Gem::List.prepend specs, act

return needed, specs
  end

##
  # Add the spec from the +possible+ list to +specs+ and process the spec's
  # dependencies by adding them to +needed+.

def resolve_for_single needed, specs, dep, possible # :nodoc:
    spec, act = activation_request dep, possible

specs = Gem::List.prepend specs, act

# Put the deps for at the beginning of needed
    # rather than the end to match the depth first
    # searching done by the multiple case code below.
    #
    # This keeps the error messages consistent.
    needed = requests spec, act, needed

return needed, specs
  end

##
  # When there are no possible specifications for +dep+ our work is done.

def resolve_for_zero dep, platform_mismatch # :nodoc:
    @missing << dep

unless @soft_missing
      exc = Gem::UnsatisfiableDependencyError.new dep, platform_mismatch
      exc.errors = @set.errors

raise exc
    end
  end

##
  # Returns the gems in +specs+ that match the local platform.

def select_local_platforms specs # :nodoc:
    specs.select do |spec|
      Gem::Platform.installable? spec
    end
  end

end

##
# TODO remove in RubyGems 3

Gem::DependencyResolver = Gem::Resolver # :nodoc:

require 'rubygems/resolver/activation_request'
require 'rubygems/resolver/conflict'
require 'rubygems/resolver/dependency_request'
require 'rubygems/resolver/requirement_list'
require 'rubygems/resolver/stats'

require 'rubygems/resolver/set'
require 'rubygems/resolver/api_set'
require 'rubygems/resolver/composed_set'
require 'rubygems/resolver/best_set'
require 'rubygems/resolver/current_set'
require 'rubygems/resolver/git_set'
require 'rubygems/resolver/index_set'
require 'rubygems/resolver/installer_set'
require 'rubygems/resolver/lock_set'
require 'rubygems/resolver/vendor_set'

require 'rubygems/resolver/specification'
require 'rubygems/resolver/spec_specification'
require 'rubygems/resolver/api_specification'
require 'rubygems/resolver/git_specification'
require 'rubygems/resolver/index_specification'
require 'rubygems/resolver/installed_specification'
require 'rubygems/resolver/local_specification'
require 'rubygems/resolver/lock_specification'
require 'rubygems/resolver/vendor_specification'

${this.title}

Code Editor : resolver.rb