Gem::DependencyList is used for installing and uninstalling gems in the correct order to avoid conflicts.

Methods
A
C
D
E
F
N
O
R
S
T
W
Included Modules
Attributes
[RW] development

Allows enabling/disabling use of development dependencies

[R] specs
Class Public methods
from_source_index(ignored=nil)

Creates a DependencyList from a Gem::SourceIndex source_index

# File lib/rubygems/dependency_list.rb, line 37
def self.from_source_index(ignored=nil)
  warn "NOTE: DependencyList.from_source_index ignores it's arg" if ignored

  from_specs
end
from_specs()

Creates a DependencyList from the current specs.

# File lib/rubygems/dependency_list.rb, line 28
def self.from_specs
  list = new
  list.add(*Gem::Specification.map)
  list
end
new(development = false)

Creates a new DependencyList. If developmentis true, development dependencies will be included.

# File lib/rubygems/dependency_list.rb, line 47
def initialize development = false
  @specs = []

  @development = development
end
Instance Public methods
add(*gemspecs)

Adds gemspecsto the dependency list.

# File lib/rubygems/dependency_list.rb, line 56
def add(*gemspecs)
  @specs.push(*gemspecs)
end
clear()
# File lib/rubygems/dependency_list.rb, line 60
def clear
  @specs.clear
end
dependency_order()

Return a list of the gem specifications in the dependency list, sorted in order so that no gemspec in the list depends on a gemspec earlier in the list.

This is useful when removing gems from a set of installed gems. By removing them in the returned order, you don't get into as many dependency issues.

If there are circular dependencies (yuck!), then gems will be returned in order until only the circular dependents and anything they reference are left. Then arbitrary gemspecs will be returned until the circular dependency is broken, after which gems will be returned in dependency order again.

# File lib/rubygems/dependency_list.rb, line 79
def dependency_order
  sorted = strongly_connected_components.flatten

  result = []
  seen = {}

  sorted.each do |spec|
    if index = seen[spec.name] then
      if result[index].version < spec.version then
        result[index] = spec
      end
    else
      seen[spec.name] = result.length
      result << spec
    end
  end

  result.reverse
end
each(&block)

Iterator over #dependency_order

# File lib/rubygems/dependency_list.rb, line 102
def each(&block)
  dependency_order.each(&block)
end
find_name(full_name)
# File lib/rubygems/dependency_list.rb, line 106
def find_name(full_name)
  @specs.find { |spec| spec.full_name == full_name }
end
ok?()

Are all the dependencies in the list satisfied?

# File lib/rubygems/dependency_list.rb, line 117
def ok?
  why_not_ok?(:quick).empty?
end
ok_to_remove?(full_name)

Is is ok to remove a gemspec from the dependency list?

If removing the gemspec creates breaks a currently ok dependency, then it is NOT ok to remove the gemspec.

# File lib/rubygems/dependency_list.rb, line 146
def ok_to_remove?(full_name)
  gem_to_remove = find_name full_name

  siblings = @specs.find_all { |s|
    s.name == gem_to_remove.name &&
      s.full_name != gem_to_remove.full_name
  }

  deps = []

  @specs.each do |spec|
    spec.dependencies.each do |dep|
      deps << dep if gem_to_remove.satisfies_requirement?(dep)
    end
  end

  deps.all? { |dep|
    siblings.any? { |s|
      s.satisfies_requirement? dep
    }
  }
end
remove_by_name(full_name)

Removes the gemspec matching full_namefrom the dependency list

# File lib/rubygems/dependency_list.rb, line 184
def remove_by_name(full_name)
  @specs.delete_if { |spec| spec.full_name == full_name }
end
remove_specs_unsatisfied_by(dependencies)

Remove everything in the DependencyList that matches but doesn't satisfy items in dependencies(a hash of gem names to arrays of dependencies).

# File lib/rubygems/dependency_list.rb, line 174
def remove_specs_unsatisfied_by dependencies
  specs.reject! { |spec|
    dep = dependencies[spec.name]
    dep and not dep.requirement.satisfied_by? spec.version
  }
end
spec_predecessors()

Return a hash of predecessors. result[spec]is an Array of gemspecs that have a dependency satisfied by the named gemspec.

# File lib/rubygems/dependency_list.rb, line 192
def spec_predecessors
  result = Hash.new { |h,k| h[k] = [] }

  specs = @specs.sort.reverse

  specs.each do |spec|
    specs.each do |other|
      next if spec == other

      other.dependencies.each do |dep|
        if spec.satisfies_requirement? dep then
          result[spec] << other
        end
      end
    end
  end

  result
end
tsort_each_child(node, &block)
# File lib/rubygems/dependency_list.rb, line 216
def tsort_each_child(node, &block)
  specs = @specs.sort.reverse

  dependencies = node.runtime_dependencies
  dependencies.push(*node.development_dependencies) if @development

  dependencies.each do |dep|
    specs.each do |spec|
      if spec.satisfies_requirement? dep then
        begin
          yield spec
        rescue TSort::Cyclic
          # do nothing
        end
        break
      end
    end
  end
end
tsort_each_node(&block)
# File lib/rubygems/dependency_list.rb, line 212
def tsort_each_node(&block)
  @specs.each(&block)
end
why_not_ok?(quick = false)
# File lib/rubygems/dependency_list.rb, line 121
def why_not_ok? quick = false
  unsatisfied = Hash.new { |h,k| h[k] = [] }
  each do |spec|
    spec.runtime_dependencies.each do |dep|
      inst = Gem::Specification.any? { |installed_spec|
        dep.name == installed_spec.name and
          dep.requirement.satisfied_by? installed_spec.version
      }

      unless inst or @specs.find { |s| s.satisfies_requirement? dep } then
        unsatisfied[spec.name] << dep
        return unsatisfied if quick
      end
    end
  end

  unsatisfied
end