Fresh start

24 files changed, 2094 insertions, 0 deletions

diff --git a/jni/ruby/lib/rubygems/resolver/activation_request.rb b/jni/ruby/lib/rubygems/resolver/activation_request.rb
new file mode 100644
index 0000000..56c6363
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/activation_request.rb
@@ -0,0 +1,172 @@
+##
+# Specifies a Specification object that should be activated.  Also contains a
+# dependency that was used to introduce this activation.
+
+class Gem::Resolver::ActivationRequest
+
+  ##
+  # The parent request for this activation request.
+
+  attr_reader :request
+
+  ##
+  # The specification to be activated.
+
+  attr_reader :spec
+
+  ##
+  # Creates a new ActivationRequest that will activate +spec+.  The parent
+  # +request+ is used to provide diagnostics in case of conflicts.
+  #
+  # +others_possible+ indicates that other specifications may also match this
+  # activation request.
+
+  def initialize spec, request, others_possible = true
+    @spec = spec
+    @request = request
+    @others_possible = others_possible
+  end
+
+  def == other # :nodoc:
+    case other
+    when Gem::Specification
+      @spec == other
+    when Gem::Resolver::ActivationRequest
+      @spec == other.spec && @request == other.request
+    else
+      false
+    end
+  end
+
+  ##
+  # Is this activation request for a development dependency?
+
+  def development?
+    @request.development?
+  end
+
+  ##
+  # Downloads a gem at +path+ and returns the file path.
+
+  def download path
+    if @spec.respond_to? :source
+      source = @spec.source
+    else
+      source = Gem.sources.first
+    end
+
+    Gem.ensure_gem_subdirectories path
+
+    source.download full_spec, path
+  end
+
+  ##
+  # The full name of the specification to be activated.
+
+  def full_name
+    @spec.full_name
+  end
+
+  ##
+  # The Gem::Specification for this activation request.
+
+  def full_spec
+    Gem::Specification === @spec ? @spec : @spec.spec
+  end
+
+  def inspect # :nodoc:
+    others =
+      case @others_possible
+      when true then # TODO remove at RubyGems 3
+        ' (others possible)'
+      when false then # TODO remove at RubyGems 3
+        nil
+      else
+        unless @others_possible.empty? then
+          others = @others_possible.map { |s| s.full_name }
+          " (others possible: #{others.join ', '})"
+        end
+      end
+
+    '#<%s for %p from %s%s>' % [
+      self.class, @spec, @request, others
+    ]
+  end
+
+  ##
+  # True if the requested gem has already been installed.
+
+  def installed?
+    case @spec
+    when Gem::Resolver::VendorSpecification then
+      true
+    else
+      this_spec = full_spec
+
+      Gem::Specification.any? do |s|
+        s == this_spec
+      end
+    end
+  end
+
+  ##
+  # The name of this activation request's specification
+
+  def name
+    @spec.name
+  end
+
+  ##
+  # Indicate if this activation is one of a set of possible
+  # requests for the same Dependency request.
+
+  def others_possible?
+    case @others_possible
+    when true, false then
+      @others_possible
+    else
+      not @others_possible.empty?
+    end
+  end
+
+  ##
+  # Return the ActivationRequest that contained the dependency
+  # that we were activated for.
+
+  def parent
+    @request.requester
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[Activation request', ']' do
+      q.breakable
+      q.pp @spec
+
+      q.breakable
+      q.text ' for '
+      q.pp @request
+
+      case @others_possible
+      when false then
+      when true then
+        q.breakable
+        q.text 'others possible'
+      else
+        unless @others_possible.empty? then
+          q.breakable
+          q.text 'others '
+          q.pp @others_possible.map { |s| s.full_name }
+        end
+      end
+    end
+  end
+
+  ##
+  # The version of this activation request's specification
+
+  def version
+    @spec.version
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/api_set.rb b/jni/ruby/lib/rubygems/resolver/api_set.rb
new file mode 100644
index 0000000..17d602f
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/api_set.rb
@@ -0,0 +1,125 @@
+##
+# The global rubygems pool, available via the rubygems.org API.
+# Returns instances of APISpecification.
+
+class Gem::Resolver::APISet < Gem::Resolver::Set
+
+  ##
+  # The URI for the dependency API this APISet uses.
+
+  attr_reader :dep_uri # :nodoc:
+
+  ##
+  # The Gem::Source that gems are fetched from
+
+  attr_reader :source
+
+  ##
+  # The corresponding place to fetch gems.
+
+  attr_reader :uri
+
+  ##
+  # Creates a new APISet that will retrieve gems from +uri+ using the RubyGems
+  # API URL +dep_uri+ which is described at
+  # http://guides.rubygems.org/rubygems-org-api
+
+  def initialize dep_uri = 'https://rubygems.org/api/v1/dependencies'
+    super()
+
+    dep_uri = URI dep_uri unless URI === dep_uri # for ruby 1.8
+
+    @dep_uri = dep_uri
+    @uri     = dep_uri + '../..'
+
+    @data   = Hash.new { |h,k| h[k] = [] }
+    @source = Gem::Source.new @uri
+
+    @to_fetch = []
+  end
+
+  ##
+  # Return an array of APISpecification objects matching
+  # DependencyRequest +req+.
+
+  def find_all req
+    res = []
+
+    return res unless @remote
+
+    if @to_fetch.include?(req.name)
+      prefetch_now
+    end
+
+    versions(req.name).each do |ver|
+      if req.dependency.match? req.name, ver[:number]
+        res << Gem::Resolver::APISpecification.new(self, ver)
+      end
+    end
+
+    res
+  end
+
+  ##
+  # A hint run by the resolver to allow the Set to fetch
+  # data for DependencyRequests +reqs+.
+
+  def prefetch reqs
+    return unless @remote
+    names = reqs.map { |r| r.dependency.name }
+    needed = names - @data.keys - @to_fetch
+
+    @to_fetch += needed
+  end
+
+  def prefetch_now # :nodoc:
+    needed, @to_fetch = @to_fetch, []
+
+    uri = @dep_uri + "?gems=#{needed.sort.join ','}"
+    str = Gem::RemoteFetcher.fetcher.fetch_path uri
+
+    loaded = []
+
+    Marshal.load(str).each do |ver|
+      name = ver[:name]
+
+      @data[name] << ver
+      loaded << name
+    end
+
+    (needed - loaded).each do |missing|
+      @data[missing] = []
+    end
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[APISet', ']' do
+      q.breakable
+      q.text "URI: #{@dep_uri}"
+
+      q.breakable
+      q.text 'gem names:'
+      q.pp @data.keys
+    end
+  end
+
+  ##
+  # Return data for all versions of the gem +name+.
+
+  def versions name # :nodoc:
+    if @data.key?(name)
+      return @data[name]
+    end
+
+    uri = @dep_uri + "?gems=#{name}"
+    str = Gem::RemoteFetcher.fetcher.fetch_path uri
+
+    Marshal.load(str).each do |ver|
+      @data[ver[:name]] << ver
+    end
+
+    @data[name]
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/api_specification.rb b/jni/ruby/lib/rubygems/resolver/api_specification.rb
new file mode 100644
index 0000000..4960e66
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/api_specification.rb
@@ -0,0 +1,85 @@
+##
+# Represents a specification retrieved via the rubygems.org API.
+#
+# This is used to avoid loading the full Specification object when all we need
+# is the name, version, and dependencies.
+
+class Gem::Resolver::APISpecification < Gem::Resolver::Specification
+
+  ##
+  # Creates an APISpecification for the given +set+ from the rubygems.org
+  # +api_data+.
+  #
+  # See http://guides.rubygems.org/rubygems-org-api/#misc_methods for the
+  # format of the +api_data+.
+
+  def initialize(set, api_data)
+    super()
+
+    @set = set
+    @name = api_data[:name]
+    @version = Gem::Version.new api_data[:number]
+    @platform = Gem::Platform.new api_data[:platform]
+    @dependencies = api_data[:dependencies].map do |name, ver|
+      Gem::Dependency.new name, ver.split(/\s*,\s*/)
+    end
+  end
+
+  def == other # :nodoc:
+    self.class === other and
+      @set          == other.set and
+      @name         == other.name and
+      @version      == other.version and
+      @platform     == other.platform and
+      @dependencies == other.dependencies
+  end
+
+  def fetch_development_dependencies # :nodoc:
+    spec = source.fetch_spec Gem::NameTuple.new @name, @version, @platform
+
+    @dependencies = spec.dependencies
+  end
+
+  def installable_platform? # :nodoc:
+    Gem::Platform.match @platform
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[APISpecification', ']' do
+      q.breakable
+      q.text "name: #{name}"
+
+      q.breakable
+      q.text "version: #{version}"
+
+      q.breakable
+      q.text "platform: #{platform}"
+
+      q.breakable
+      q.text 'dependencies:'
+      q.breakable
+      q.pp @dependencies
+
+      q.breakable
+      q.text "set uri: #{@set.dep_uri}"
+    end
+  end
+
+  ##
+  # Fetches a Gem::Specification for this APISpecification.
+
+  def spec # :nodoc:
+    @spec ||=
+      begin
+        tuple = Gem::NameTuple.new @name, @version, @platform
+
+        source.fetch_spec tuple
+      end
+  end
+
+  def source # :nodoc:
+    @set.source
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/best_set.rb b/jni/ruby/lib/rubygems/resolver/best_set.rb
new file mode 100644
index 0000000..7e2d7e2
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/best_set.rb
@@ -0,0 +1,78 @@
+##
+# The BestSet chooses the best available method to query a remote index.
+#
+# It combines IndexSet and APISet
+
+class Gem::Resolver::BestSet < Gem::Resolver::ComposedSet
+
+  ##
+  # Creates a BestSet for the given +sources+ or Gem::sources if none are
+  # specified.  +sources+ must be a Gem::SourceList.
+
+  def initialize sources = Gem.sources
+    super()
+
+    @sources = sources
+  end
+
+  ##
+  # Picks which sets to use for the configured sources.
+
+  def pick_sets # :nodoc:
+    @sources.each_source do |source|
+      @sets << source.dependency_resolver_set
+    end
+  end
+
+  def find_all req # :nodoc:
+    pick_sets if @remote and @sets.empty?
+
+    super
+  rescue Gem::RemoteFetcher::FetchError => e
+    replace_failed_api_set e
+
+    retry
+  end
+
+  def prefetch reqs # :nodoc:
+    pick_sets if @remote and @sets.empty?
+
+    super
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[BestSet', ']' do
+      q.breakable
+      q.text 'sets:'
+
+      q.breakable
+      q.pp @sets
+    end
+  end
+
+  ##
+  # Replaces a failed APISet for the URI in +error+ with an IndexSet.
+  #
+  # If no matching APISet can be found the original +error+ is raised.
+  #
+  # The calling method must retry the exception to repeat the lookup.
+
+  def replace_failed_api_set error # :nodoc:
+    uri = error.uri
+    uri = URI uri unless URI === uri
+    uri.query = nil
+
+    raise error unless api_set = @sets.find { |set|
+      Gem::Resolver::APISet === set and set.dep_uri == uri
+    }
+
+    index_set = Gem::Resolver::IndexSet.new api_set.source
+
+    @sets.map! do |set|
+      next set unless set == api_set
+      index_set
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/composed_set.rb b/jni/ruby/lib/rubygems/resolver/composed_set.rb
new file mode 100644
index 0000000..5b08f12
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/composed_set.rb
@@ -0,0 +1,66 @@
+##
+# A ComposedSet allows multiple sets to be queried like a single set.
+#
+# To create a composed set with any number of sets use:
+#
+#   Gem::Resolver.compose_sets set1, set2
+#
+# This method will eliminate nesting of composed sets.
+
+class Gem::Resolver::ComposedSet < Gem::Resolver::Set
+
+  attr_reader :sets # :nodoc:
+
+  ##
+  # Creates a new ComposedSet containing +sets+.  Use
+  # Gem::Resolver::compose_sets instead.
+
+  def initialize *sets
+    super()
+
+    @sets = sets
+  end
+
+  ##
+  # When +allow_prerelease+ is set to +true+ prereleases gems are allowed to
+  # match dependencies.
+
+  def prerelease= allow_prerelease
+    super
+
+    sets.each do |set|
+      set.prerelease = allow_prerelease
+    end
+  end
+
+  ##
+  # Sets the remote network access for all composed sets.
+
+  def remote= remote
+    super
+
+    @sets.each { |set| set.remote = remote }
+  end
+
+  def errors
+    @errors + @sets.map { |set| set.errors }.flatten
+  end
+
+  ##
+  # Finds all specs matching +req+ in all sets.
+
+  def find_all req
+    @sets.map do |s|
+      s.find_all req
+    end.flatten
+  end
+
+  ##
+  # Prefetches +reqs+ in all sets.
+
+  def prefetch reqs
+    @sets.each { |s| s.prefetch(reqs) }
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/conflict.rb b/jni/ruby/lib/rubygems/resolver/conflict.rb
new file mode 100644
index 0000000..902c286
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/conflict.rb
@@ -0,0 +1,160 @@
+##
+# Used internally to indicate that a dependency conflicted
+# with a spec that would be activated.
+
+class Gem::Resolver::Conflict
+
+  ##
+  # The specification that was activated prior to the conflict
+
+  attr_reader :activated
+
+  ##
+  # The dependency that is in conflict with the activated gem.
+
+  attr_reader :dependency
+
+  attr_reader :failed_dep # :nodoc:
+
+  ##
+  # Creates a new resolver conflict when +dependency+ is in conflict with an
+  # already +activated+ specification.
+
+  def initialize(dependency, activated, failed_dep=dependency)
+    @dependency = dependency
+    @activated = activated
+    @failed_dep = failed_dep
+  end
+
+  def == other # :nodoc:
+    self.class === other and
+      @dependency == other.dependency and
+      @activated  == other.activated  and
+      @failed_dep == other.failed_dep
+  end
+
+  ##
+  # A string explanation of the conflict.
+
+  def explain
+    "<Conflict wanted: #{@failed_dep}, had: #{activated.spec.full_name}>"
+  end
+
+  ##
+  # Return the 2 dependency objects that conflicted
+
+  def conflicting_dependencies
+    [@failed_dep.dependency, @activated.request.dependency]
+  end
+
+  ##
+  # Explanation of the conflict used by exceptions to print useful messages
+
+  def explanation
+    activated   = @activated.spec.full_name
+    dependency  = @failed_dep.dependency
+    requirement = dependency.requirement
+    alternates  = dependency.matching_specs.map { |spec| spec.full_name }
+
+    unless alternates.empty? then
+      matching = <<-MATCHING.chomp
+
+  Gems matching %s:
+    %s
+      MATCHING
+
+      matching = matching % [
+        dependency,
+        alternates.join(', '),
+      ]
+    end
+
+    explanation = <<-EXPLANATION
+  Activated %s
+  which does not match conflicting dependency (%s)
+
+  Conflicting dependency chains:
+    %s
+
+  versus:
+    %s
+%s
+    EXPLANATION
+
+    explanation % [
+      activated, requirement,
+      request_path(@activated).reverse.join(", depends on\n    "),
+      request_path(@failed_dep).reverse.join(", depends on\n    "),
+      matching,
+    ]
+  end
+
+  ##
+  # Returns true if the conflicting dependency's name matches +spec+.
+
+  def for_spec?(spec)
+    @dependency.name == spec.name
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[Dependency conflict: ', ']' do
+      q.breakable
+
+      q.text 'activated '
+      q.pp @activated
+
+      q.breakable
+      q.text ' dependency '
+      q.pp @dependency
+
+      q.breakable
+      if @dependency == @failed_dep then
+        q.text ' failed'
+      else
+        q.text ' failed dependency '
+        q.pp @failed_dep
+      end
+    end
+  end
+
+  ##
+  # Path of activations from the +current+ list.
+
+  def request_path current
+    path = []
+
+    while current do
+      case current
+      when Gem::Resolver::ActivationRequest then
+        path <<
+          "#{current.request.dependency}, #{current.spec.version} activated"
+
+        current = current.parent
+      when Gem::Resolver::DependencyRequest then
+        path << "#{current.dependency}"
+
+        current = current.requester
+      else
+        raise Gem::Exception, "[BUG] unknown request class #{current.class}"
+      end
+    end
+
+    path = ['user request (gem command or Gemfile)'] if path.empty?
+
+    path
+  end
+
+  ##
+  # Return the Specification that listed the dependency
+
+  def requester
+    @failed_dep.requester
+  end
+
+end
+
+##
+# TODO: Remove in RubyGems 3
+
+Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict # :nodoc:
+
diff --git a/jni/ruby/lib/rubygems/resolver/current_set.rb b/jni/ruby/lib/rubygems/resolver/current_set.rb
new file mode 100644
index 0000000..4e8d340
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/current_set.rb
@@ -0,0 +1,13 @@
+##
+# A set which represents the installed gems. Respects
+# all the normal settings that control where to look
+# for installed gems.
+
+class Gem::Resolver::CurrentSet < Gem::Resolver::Set
+
+  def find_all req
+    req.dependency.matching_specs
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/dependency_request.rb b/jni/ruby/lib/rubygems/resolver/dependency_request.rb
new file mode 100644
index 0000000..79690be
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/dependency_request.rb
@@ -0,0 +1,116 @@
+##
+# Used Internally. Wraps a Dependency object to also track which spec
+# contained the Dependency.
+
+class Gem::Resolver::DependencyRequest
+
+  ##
+  # The wrapped Gem::Dependency
+
+  attr_reader :dependency
+
+  ##
+  # The request for this dependency.
+
+  attr_reader :requester
+
+  ##
+  # Creates a new DependencyRequest for +dependency+ from +requester+.
+  # +requester may be nil if the request came from a user.
+
+  def initialize dependency, requester
+    @dependency = dependency
+    @requester  = requester
+  end
+
+  def == other # :nodoc:
+    case other
+    when Gem::Dependency
+      @dependency == other
+    when Gem::Resolver::DependencyRequest
+      @dependency == other.dependency && @requester == other.requester
+    else
+      false
+    end
+  end
+
+  ##
+  # Is this dependency a development dependency?
+
+  def development?
+    @dependency.type == :development
+  end
+
+  ##
+  # Does this dependency request match +spec+?
+  #
+  # NOTE:  #match? only matches prerelease versions when #dependency is a
+  # prerelease dependency.
+
+  def match? spec, allow_prerelease = false
+    @dependency.match? spec, nil, allow_prerelease
+  end
+
+  ##
+  # Does this dependency request match +spec+?
+  #
+  # NOTE:  #matches_spec? matches prerelease versions.  See also #match?
+
+  def matches_spec?(spec)
+    @dependency.matches_spec? spec
+  end
+
+  ##
+  # The name of the gem this dependency request is requesting.
+
+  def name
+    @dependency.name
+  end
+
+  ##
+  # Indicate that the request is for a gem explicitly requested by the user
+
+  def explicit?
+    @requester.nil?
+  end
+
+  ##
+  # Indicate that the request is for a gem requested as a dependency of
+  # another gem
+
+  def implicit?
+    !explicit?
+  end
+
+  ##
+  # Return a String indicating who caused this request to be added (only
+  # valid for implicit requests)
+
+  def request_context
+    @requester ? @requester.request : "(unknown)"
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[Dependency request ', ']' do
+      q.breakable
+      q.text @dependency.to_s
+
+      q.breakable
+      q.text ' requested by '
+      q.pp @requester
+    end
+  end
+
+  ##
+  # The version requirement for this dependency request
+
+  def requirement
+    @dependency.requirement
+  end
+
+  def to_s # :nodoc:
+    @dependency.to_s
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/git_set.rb b/jni/ruby/lib/rubygems/resolver/git_set.rb
new file mode 100644
index 0000000..5f1b368
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/git_set.rb
@@ -0,0 +1,122 @@
+##
+# A GitSet represents gems that are sourced from git repositories.
+#
+# This is used for gem dependency file support.
+#
+# Example:
+#
+#   set = Gem::Resolver::GitSet.new
+#   set.add_git_gem 'rake', 'git://example/rake.git', tag: 'rake-10.1.0'
+
+class Gem::Resolver::GitSet < Gem::Resolver::Set
+
+  ##
+  # The root directory for git gems in this set.  This is usually Gem.dir, the
+  # installation directory for regular gems.
+
+  attr_accessor :root_dir
+
+  ##
+  # Contains repositories needing submodules
+
+  attr_reader :need_submodules # :nodoc:
+
+  ##
+  # A Hash containing git gem names for keys and a Hash of repository and
+  # git commit reference as values.
+
+  attr_reader :repositories # :nodoc:
+
+  ##
+  # A hash of gem names to Gem::Resolver::GitSpecifications
+
+  attr_reader :specs # :nodoc:
+
+  def initialize # :nodoc:
+    super()
+
+    @git             = ENV['git'] || 'git'
+    @need_submodules = {}
+    @repositories    = {}
+    @root_dir        = Gem.dir
+    @specs           = {}
+  end
+
+  def add_git_gem name, repository, reference, submodules # :nodoc:
+    @repositories[name] = [repository, reference]
+    @need_submodules[repository] = submodules
+  end
+
+  ##
+  # Adds and returns a GitSpecification with the given +name+ and +version+
+  # which came from a +repository+ at the given +reference+.  If +submodules+
+  # is true they are checked out along with the repository.
+  #
+  # This fills in the prefetch information as enough information about the gem
+  # is present in the arguments.
+
+  def add_git_spec name, version, repository, reference, submodules # :nodoc:
+    add_git_gem name, repository, reference, submodules
+
+    source = Gem::Source::Git.new name, repository, reference
+    source.root_dir = @root_dir
+
+    spec = Gem::Specification.new do |s|
+      s.name    = name
+      s.version = version
+    end
+
+    git_spec = Gem::Resolver::GitSpecification.new self, spec, source
+
+    @specs[spec.name] = git_spec
+
+    git_spec
+  end
+
+  ##
+  # Finds all git gems matching +req+
+
+  def find_all req
+    prefetch nil
+
+    specs.values.select do |spec|
+      req.match? spec
+    end
+  end
+
+  ##
+  # Prefetches specifications from the git repositories in this set.
+
+  def prefetch reqs
+    return unless @specs.empty?
+
+    @repositories.each do |name, (repository, reference)|
+      source = Gem::Source::Git.new name, repository, reference
+      source.root_dir = @root_dir
+      source.remote = @remote
+
+      source.specs.each do |spec|
+        git_spec = Gem::Resolver::GitSpecification.new self, spec, source
+
+        @specs[spec.name] = git_spec
+      end
+    end
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[GitSet', ']' do
+      next if @repositories.empty?
+      q.breakable
+
+      repos = @repositories.map do |name, (repository, reference)|
+        "#{name}: #{repository}@#{reference}"
+      end
+
+      q.seplist repos do |repo|
+        q.text repo
+      end
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/git_specification.rb b/jni/ruby/lib/rubygems/resolver/git_specification.rb
new file mode 100644
index 0000000..55e180e
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/git_specification.rb
@@ -0,0 +1,59 @@
+##
+# A GitSpecification represents a gem that is sourced from a git repository
+# and is being loaded through a gem dependencies file through the +git:+
+# option.
+
+class Gem::Resolver::GitSpecification < Gem::Resolver::SpecSpecification
+
+  def == other # :nodoc:
+    self.class === other and
+      @set  == other.set and
+      @spec == other.spec and
+      @source == other.source
+  end
+
+  def add_dependency dependency # :nodoc:
+    spec.dependencies << dependency
+  end
+
+  ##
+  # Installing a git gem only involves building the extensions and generating
+  # the executables.
+
+  def install options = {}
+    require 'rubygems/installer'
+
+    installer = Gem::Installer.new '', options
+    installer.spec = spec
+
+    yield installer if block_given?
+
+    installer.run_pre_install_hooks
+    installer.build_extensions
+    installer.run_post_build_hooks
+    installer.generate_bin
+    installer.run_post_install_hooks
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[GitSpecification', ']' do
+      q.breakable
+      q.text "name: #{name}"
+
+      q.breakable
+      q.text "version: #{version}"
+
+      q.breakable
+      q.text 'dependencies:'
+      q.breakable
+      q.pp dependencies
+
+      q.breakable
+      q.text "source:"
+      q.breakable
+      q.pp @source
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/index_set.rb b/jni/ruby/lib/rubygems/resolver/index_set.rb
new file mode 100644
index 0000000..7c56c2b
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/index_set.rb
@@ -0,0 +1,80 @@
+##
+# The global rubygems pool represented via the traditional
+# source index.
+
+class Gem::Resolver::IndexSet < Gem::Resolver::Set
+
+  def initialize source = nil # :nodoc:
+    super()
+
+    @f =
+      if source then
+        sources = Gem::SourceList.from [source]
+
+        Gem::SpecFetcher.new sources
+      else
+        Gem::SpecFetcher.fetcher
+      end
+
+    @all = Hash.new { |h,k| h[k] = [] }
+
+    list, errors = @f.available_specs :complete
+
+    @errors.concat errors
+
+    list.each do |uri, specs|
+      specs.each do |n|
+        @all[n.name] << [uri, n]
+      end
+    end
+
+    @specs = {}
+  end
+
+  ##
+  # Return an array of IndexSpecification objects matching
+  # DependencyRequest +req+.
+
+  def find_all req
+    res = []
+
+    return res unless @remote
+
+    name = req.dependency.name
+
+    @all[name].each do |uri, n|
+      if req.match? n, @prerelease then
+        res << Gem::Resolver::IndexSpecification.new(
+          self, n.name, n.version, uri, n.platform)
+      end
+    end
+
+    res
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[IndexSet', ']' do
+      q.breakable
+      q.text 'sources:'
+      q.breakable
+      q.pp @f.sources
+
+      q.breakable
+      q.text 'specs:'
+
+      q.breakable
+
+      names = @all.values.map do |tuples|
+        tuples.map do |_, tuple|
+          tuple.full_name
+        end
+      end.flatten
+
+      q.seplist names do |name|
+        q.text name
+      end
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/index_specification.rb b/jni/ruby/lib/rubygems/resolver/index_specification.rb
new file mode 100644
index 0000000..56fecb5
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/index_specification.rb
@@ -0,0 +1,69 @@
+##
+# Represents a possible Specification object returned from IndexSet.  Used to
+# delay needed to download full Specification objects when only the +name+
+# and +version+ are needed.
+
+class Gem::Resolver::IndexSpecification < Gem::Resolver::Specification
+
+  ##
+  # An IndexSpecification is created from the index format described in `gem
+  # help generate_index`.
+  #
+  # The +set+ contains other specifications for this (URL) +source+.
+  #
+  # The +name+, +version+ and +platform+ are the name, version and platform of
+  # the gem.
+
+  def initialize set, name, version, source, platform
+    super()
+
+    @set = set
+    @name = name
+    @version = version
+    @source = source
+    @platform = platform.to_s
+
+    @spec = nil
+  end
+
+  ##
+  # The dependencies of the gem for this specification
+
+  def dependencies
+    spec.dependencies
+  end
+
+  def inspect # :nodoc:
+    '#<%s %s source %s>' % [self.class, full_name, @source]
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[Index specification', ']' do
+      q.breakable
+      q.text full_name
+
+      unless Gem::Platform::RUBY == @platform then
+        q.breakable
+        q.text @platform.to_s
+      end
+
+      q.breakable
+      q.text 'source '
+      q.pp @source
+    end
+  end
+
+  ##
+  # Fetches a Gem::Specification for this IndexSpecification from the #source.
+
+  def spec # :nodoc:
+    @spec ||=
+      begin
+        tuple = Gem::NameTuple.new @name, @version, @platform
+
+        @source.fetch_spec tuple
+      end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/installed_specification.rb b/jni/ruby/lib/rubygems/resolver/installed_specification.rb
new file mode 100644
index 0000000..2a2b89a
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/installed_specification.rb
@@ -0,0 +1,58 @@
+##
+# An InstalledSpecification represents a gem that is already installed
+# locally.
+
+class Gem::Resolver::InstalledSpecification < Gem::Resolver::SpecSpecification
+
+  def == other # :nodoc:
+    self.class === other and
+      @set  == other.set and
+      @spec == other.spec
+  end
+
+  ##
+  # This is a null install as this specification is already installed.
+  # +options+ are ignored.
+
+  def install options = {}
+    yield nil
+  end
+
+  ##
+  # Returns +true+ if this gem is installable for the current platform.
+
+  def installable_platform?
+    # BACKCOMPAT If the file is coming out of a specified file, then we
+    # ignore the platform. This code can be removed in RG 3.0.
+    return true if @source.kind_of? Gem::Source::SpecificFile
+
+    super
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[InstalledSpecification', ']' do
+      q.breakable
+      q.text "name: #{name}"
+
+      q.breakable
+      q.text "version: #{version}"
+
+      q.breakable
+      q.text "platform: #{platform}"
+
+      q.breakable
+      q.text 'dependencies:'
+      q.breakable
+      q.pp spec.dependencies
+    end
+  end
+
+  ##
+  # The source for this specification
+
+  def source
+    @source ||= Gem::Source::Installed.new
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/installer_set.rb b/jni/ruby/lib/rubygems/resolver/installer_set.rb
new file mode 100644
index 0000000..a68ff09
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/installer_set.rb
@@ -0,0 +1,224 @@
+##
+# A set of gems for installation sourced from remote sources and local .gem
+# files
+
+class Gem::Resolver::InstallerSet < Gem::Resolver::Set
+
+  ##
+  # List of Gem::Specification objects that must always be installed.
+
+  attr_reader :always_install # :nodoc:
+
+  ##
+  # Only install gems in the always_install list
+
+  attr_accessor :ignore_dependencies # :nodoc:
+
+  ##
+  # Do not look in the installed set when finding specifications.  This is
+  # used by the --install-dir option to `gem install`
+
+  attr_accessor :ignore_installed # :nodoc:
+
+  ##
+  # The remote_set looks up remote gems for installation.
+
+  attr_reader :remote_set # :nodoc:
+
+  ##
+  # Creates a new InstallerSet that will look for gems in +domain+.
+
+  def initialize domain
+    super()
+
+    @domain = domain
+    @remote = consider_remote?
+
+    @f = Gem::SpecFetcher.fetcher
+
+    @always_install      = []
+    @ignore_dependencies = false
+    @ignore_installed    = false
+    @local               = {}
+    @remote_set          = Gem::Resolver::BestSet.new
+    @specs               = {}
+  end
+
+  ##
+  # Looks up the latest specification for +dependency+ and adds it to the
+  # always_install list.
+
+  def add_always_install dependency
+    request = Gem::Resolver::DependencyRequest.new dependency, nil
+
+    found = find_all request
+
+    found.delete_if { |s|
+      s.version.prerelease? and not s.local?
+    } unless dependency.prerelease?
+
+    found = found.select do |s|
+      Gem::Source::SpecificFile === s.source or
+        Gem::Platform::RUBY == s.platform or
+        Gem::Platform.local === s.platform
+    end
+
+    if found.empty? then
+      exc = Gem::UnsatisfiableDependencyError.new request
+      exc.errors = errors
+
+      raise exc
+    end
+
+    newest = found.max_by do |s|
+      [s.version, s.platform == Gem::Platform::RUBY ? -1 : 1]
+    end
+
+    @always_install << newest.spec
+  end
+
+  ##
+  # Adds a local gem requested using +dep_name+ with the given +spec+ that can
+  # be loaded and installed using the +source+.
+
+  def add_local dep_name, spec, source
+    @local[dep_name] = [spec, source]
+  end
+
+  ##
+  # Should local gems should be considered?
+
+  def consider_local? # :nodoc:
+    @domain == :both or @domain == :local
+  end
+
+  ##
+  # Should remote gems should be considered?
+
+  def consider_remote? # :nodoc:
+    @domain == :both or @domain == :remote
+  end
+
+  ##
+  # Errors encountered while resolving gems
+
+  def errors
+    @errors + @remote_set.errors
+  end
+
+  ##
+  # Returns an array of IndexSpecification objects matching DependencyRequest
+  # +req+.
+
+  def find_all req
+    res = []
+
+    dep  = req.dependency
+
+    return res if @ignore_dependencies and
+              @always_install.none? { |spec| dep.match? spec }
+
+    name = dep.name
+
+    dep.matching_specs.each do |gemspec|
+      next if @always_install.any? { |spec| spec.name == gemspec.name }
+
+      res << Gem::Resolver::InstalledSpecification.new(self, gemspec)
+    end unless @ignore_installed
+
+    if consider_local? then
+      matching_local = @local.values.select do |spec, _|
+        req.match? spec
+      end.map do |spec, source|
+        Gem::Resolver::LocalSpecification.new self, spec, source
+      end
+
+      res.concat matching_local
+
+      local_source = Gem::Source::Local.new
+
+      if local_spec = local_source.find_gem(name, dep.requirement) then
+        res << Gem::Resolver::IndexSpecification.new(
+          self, local_spec.name, local_spec.version,
+          local_source, local_spec.platform)
+      end
+    end
+
+    res.delete_if do |spec|
+      spec.version.prerelease? and not dep.prerelease?
+    end
+
+    res.concat @remote_set.find_all req if consider_remote?
+
+    res
+  end
+
+  def prefetch(reqs)
+    @remote_set.prefetch(reqs) if consider_remote?
+  end
+
+  def prerelease= allow_prerelease
+    super
+
+    @remote_set.prerelease = allow_prerelease
+  end
+
+  def inspect # :nodoc:
+    always_install = @always_install.map { |s| s.full_name }
+
+    '#<%s domain: %s specs: %p always install: %p>' % [
+      self.class, @domain, @specs.keys, always_install,
+    ]
+  end
+
+  ##
+  # Called from IndexSpecification to get a true Specification
+  # object.
+
+  def load_spec name, ver, platform, source # :nodoc:
+    key = "#{name}-#{ver}-#{platform}"
+
+    @specs.fetch key do
+      tuple = Gem::NameTuple.new name, ver, platform
+
+      @specs[key] = source.fetch_spec tuple
+    end
+  end
+
+  ##
+  # Has a local gem for +dep_name+ been added to this set?
+
+  def local? dep_name # :nodoc:
+    spec, = @local[dep_name]
+
+    spec
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[InstallerSet', ']' do
+      q.breakable
+      q.text "domain: #{@domain}"
+
+      q.breakable
+      q.text 'specs: '
+      q.pp @specs.keys
+
+      q.breakable
+      q.text 'always install: '
+      q.pp @always_install
+    end
+  end
+
+  def remote= remote # :nodoc:
+    case @domain
+    when :local then
+      @domain = :both if remote
+    when :remote then
+      @domain = nil unless remote
+    when :both then
+      @domain = :local unless remote
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/local_specification.rb b/jni/ruby/lib/rubygems/resolver/local_specification.rb
new file mode 100644
index 0000000..20a283f
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/local_specification.rb
@@ -0,0 +1,41 @@
+##
+# A LocalSpecification comes from a .gem file on the local filesystem.
+
+class Gem::Resolver::LocalSpecification < Gem::Resolver::SpecSpecification
+
+  ##
+  # Returns +true+ if this gem is installable for the current platform.
+
+  def installable_platform?
+    return true if @source.kind_of? Gem::Source::SpecificFile
+
+    super
+  end
+
+  def local? # :nodoc:
+    true
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[LocalSpecification', ']' do
+      q.breakable
+      q.text "name: #{name}"
+
+      q.breakable
+      q.text "version: #{version}"
+
+      q.breakable
+      q.text "platform: #{platform}"
+
+      q.breakable
+      q.text 'dependencies:'
+      q.breakable
+      q.pp dependencies
+
+      q.breakable
+      q.text "source: #{@source.path}"
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/lock_set.rb b/jni/ruby/lib/rubygems/resolver/lock_set.rb
new file mode 100644
index 0000000..4ede597
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/lock_set.rb
@@ -0,0 +1,84 @@
+##
+# A set of gems from a gem dependencies lockfile.
+
+class Gem::Resolver::LockSet < Gem::Resolver::Set
+
+  attr_reader :specs # :nodoc:
+
+  ##
+  # Creates a new LockSet from the given +sources+
+
+  def initialize sources
+    super()
+
+    @sources = sources.map do |source|
+      Gem::Source::Lock.new source
+    end
+
+    @specs   = []
+  end
+
+  ##
+  # Creates a new IndexSpecification in this set using the given +name+,
+  # +version+ and +platform+.
+  #
+  # The specification's set will be the current set, and the source will be
+  # the current set's source.
+
+  def add name, version, platform # :nodoc:
+    version = Gem::Version.new version
+
+    specs = @sources.map do |source|
+      Gem::Resolver::LockSpecification.new self, name, version, source,
+                                           platform
+    end
+
+    @specs.concat specs
+
+    specs
+  end
+
+  ##
+  # Returns an Array of IndexSpecification objects matching the
+  # DependencyRequest +req+.
+
+  def find_all req
+    @specs.select do |spec|
+      req.match? spec
+    end
+  end
+
+  ##
+  # Loads a Gem::Specification with the given +name+, +version+ and
+  # +platform+.  +source+ is ignored.
+
+  def load_spec name, version, platform, source # :nodoc:
+    dep = Gem::Dependency.new name, version
+
+    found = @specs.find do |spec|
+      dep.matches_spec? spec and spec.platform == platform
+    end
+
+    tuple = Gem::NameTuple.new found.name, found.version, found.platform
+
+    found.source.fetch_spec tuple
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[LockSet', ']' do
+      q.breakable
+      q.text 'source:'
+
+      q.breakable
+      q.pp @source
+
+      q.breakable
+      q.text 'specs:'
+
+      q.breakable
+      q.pp @specs.map { |spec| spec.full_name }
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/lock_specification.rb b/jni/ruby/lib/rubygems/resolver/lock_specification.rb
new file mode 100644
index 0000000..0013171
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/lock_specification.rb
@@ -0,0 +1,84 @@
+##
+# The LockSpecification comes from a lockfile (Gem::RequestSet::Lockfile).
+#
+# A LockSpecification's dependency information is pre-filled from the
+# lockfile.
+
+class Gem::Resolver::LockSpecification < Gem::Resolver::Specification
+
+  def initialize set, name, version, source, platform
+    super()
+
+    @name     = name
+    @platform = platform
+    @set      = set
+    @source   = source
+    @version  = version
+
+    @dependencies = []
+    @spec         = nil
+  end
+
+  ##
+  # This is a null install as a locked specification is considered installed.
+  # +options+ are ignored.
+
+  def install options = {}
+    destination = options[:install_dir] || Gem.dir
+
+    if File.exist? File.join(destination, 'specifications', spec.spec_name) then
+      yield nil
+      return
+    end
+
+    super
+  end
+
+  ##
+  # Adds +dependency+ from the lockfile to this specification
+
+  def add_dependency dependency # :nodoc:
+    @dependencies << dependency
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[LockSpecification', ']' do
+      q.breakable
+      q.text "name: #{@name}"
+
+      q.breakable
+      q.text "version: #{@version}"
+
+      unless @platform == Gem::Platform::RUBY then
+        q.breakable
+        q.text "platform: #{@platform}"
+      end
+
+      unless @dependencies.empty? then
+        q.breakable
+        q.text 'dependencies:'
+        q.breakable
+        q.pp @dependencies
+      end
+    end
+  end
+
+  ##
+  # A specification constructed from the lockfile is returned
+
+  def spec
+    @spec ||= Gem::Specification.find { |spec|
+      spec.name == @name and spec.version == @version
+    }
+
+    @spec ||= Gem::Specification.new do |s|
+      s.name     = @name
+      s.version  = @version
+      s.platform = @platform
+
+      s.dependencies.concat @dependencies
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/requirement_list.rb b/jni/ruby/lib/rubygems/resolver/requirement_list.rb
new file mode 100644
index 0000000..a6bfaab
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/requirement_list.rb
@@ -0,0 +1,81 @@
+##
+# The RequirementList is used to hold the requirements being considered
+# while resolving a set of gems.
+#
+# The RequirementList acts like a queue where the oldest items are removed
+# first.
+
+class Gem::Resolver::RequirementList
+
+  include Enumerable
+
+  ##
+  # Creates a new RequirementList.
+
+  def initialize
+    @exact = []
+    @list = []
+  end
+
+  def initialize_copy other # :nodoc:
+    @exact = @exact.dup
+    @list = @list.dup
+  end
+
+  ##
+  # Adds Resolver::DependencyRequest +req+ to this requirements list.
+
+  def add(req)
+    if req.requirement.exact?
+      @exact.push req
+    else
+      @list.push req
+    end
+    req
+  end
+
+  ##
+  # Enumerates requirements in the list
+
+  def each # :nodoc:
+    return enum_for __method__ unless block_given?
+
+    @exact.each do |requirement|
+      yield requirement
+    end
+
+    @list.each do |requirement|
+      yield requirement
+    end
+  end
+
+  ##
+  # How many elements are in the list
+
+  def size
+    @exact.size + @list.size
+  end
+
+  ##
+  # Is the list empty?
+
+  def empty?
+    @exact.empty? && @list.empty?
+  end
+
+  ##
+  # Remove the oldest DependencyRequest from the list.
+
+  def remove
+    return @exact.shift unless @exact.empty?
+    @list.shift
+  end
+
+  ##
+  # Returns the oldest five entries from the list.
+
+  def next5
+    x = @exact[0,5]
+    x + @list[0,5 - x.size]
+  end
+end
diff --git a/jni/ruby/lib/rubygems/resolver/set.rb b/jni/ruby/lib/rubygems/resolver/set.rb
new file mode 100644
index 0000000..b26dc45
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/set.rb
@@ -0,0 +1,56 @@
+##
+# Resolver sets are used to look up specifications (and their
+# dependencies) used in resolution.  This set is abstract.
+
+class Gem::Resolver::Set
+
+  ##
+  # Set to true to disable network access for this set
+
+  attr_accessor :remote
+
+  ##
+  # Errors encountered when resolving gems
+
+  attr_accessor :errors
+
+  ##
+  # When true, allows matching of requests to prerelease gems.
+
+  attr_accessor :prerelease
+
+  def initialize # :nodoc:
+    @prerelease = false
+    @remote     = true
+    @errors     = []
+  end
+
+  ##
+  # The find_all method must be implemented.  It returns all Resolver
+  # Specification objects matching the given DependencyRequest +req+.
+
+  def find_all req
+    raise NotImplementedError
+  end
+
+  ##
+  # The #prefetch method may be overridden, but this is not necessary.  This
+  # default implementation does nothing, which is suitable for sets where
+  # looking up a specification is cheap (such as installed gems).
+  #
+  # When overridden, the #prefetch method should look up specifications
+  # matching +reqs+.
+
+  def prefetch reqs
+  end
+
+  ##
+  # When true, this set is allowed to access the network when looking up
+  # specifications or dependencies.
+
+  def remote? # :nodoc:
+    @remote
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/spec_specification.rb b/jni/ruby/lib/rubygems/resolver/spec_specification.rb
new file mode 100644
index 0000000..1350e8a
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/spec_specification.rb
@@ -0,0 +1,56 @@
+##
+# The Resolver::SpecSpecification contains common functionality for
+# Resolver specifications that are backed by a Gem::Specification.
+
+class Gem::Resolver::SpecSpecification < Gem::Resolver::Specification
+
+  ##
+  # A SpecSpecification is created for a +set+ for a Gem::Specification in
+  # +spec+.  The +source+ is either where the +spec+ came from, or should be
+  # loaded from.
+
+  def initialize set, spec, source = nil
+    @set    = set
+    @source = source
+    @spec   = spec
+  end
+
+  ##
+  # The dependencies of the gem for this specification
+
+  def dependencies
+    spec.dependencies
+  end
+
+  ##
+  # The name and version of the specification.
+  #
+  # Unlike Gem::Specification#full_name, the platform is not included.
+
+  def full_name
+    "#{spec.name}-#{spec.version}"
+  end
+
+  ##
+  # The name of the gem for this specification
+
+  def name
+    spec.name
+  end
+
+  ##
+  # The platform this gem works on.
+
+  def platform
+    spec.platform
+  end
+
+  ##
+  # The version of the gem for this specification.
+
+  def version
+    spec.version
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/specification.rb b/jni/ruby/lib/rubygems/resolver/specification.rb
new file mode 100644
index 0000000..4d77293
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/specification.rb
@@ -0,0 +1,110 @@
+##
+# A Resolver::Specification contains a subset of the information
+# contained in a Gem::Specification.  Only the information necessary for
+# dependency resolution in the resolver is included.
+
+class Gem::Resolver::Specification
+
+  ##
+  # The dependencies of the gem for this specification
+
+  attr_reader :dependencies
+
+  ##
+  # The name of the gem for this specification
+
+  attr_reader :name
+
+  ##
+  # The platform this gem works on.
+
+  attr_reader :platform
+
+  ##
+  # The set this specification came from.
+
+  attr_reader :set
+
+  ##
+  # The source for this specification
+
+  attr_reader :source
+
+  ##
+  # The Gem::Specification for this Resolver::Specification.
+  #
+  # Implementers, note that #install updates @spec, so be sure to cache the
+  # Gem::Specification in @spec when overriding.
+
+  attr_reader :spec
+
+  ##
+  # The version of the gem for this specification.
+
+  attr_reader :version
+
+  ##
+  # Sets default instance variables for the specification.
+
+  def initialize
+    @dependencies = nil
+    @name         = nil
+    @platform     = nil
+    @set          = nil
+    @source       = nil
+    @version      = nil
+  end
+
+  ##
+  # Fetches development dependencies if the source does not provide them by
+  # default (see APISpecification).
+
+  def fetch_development_dependencies # :nodoc:
+  end
+
+  ##
+  # The name and version of the specification.
+  #
+  # Unlike Gem::Specification#full_name, the platform is not included.
+
+  def full_name
+    "#{@name}-#{@version}"
+  end
+
+  ##
+  # Installs this specification using the Gem::Installer +options+.  The
+  # install method yields a Gem::Installer instance, which indicates the
+  # gem will be installed, or +nil+, which indicates the gem is already
+  # installed.
+  #
+  # After installation #spec is updated to point to the just-installed
+  # specification.
+
+  def install options = {}
+    require 'rubygems/installer'
+
+    destination = options[:install_dir] || Gem.dir
+
+    Gem.ensure_gem_subdirectories destination
+
+    gem = source.download spec, destination
+
+    installer = Gem::Installer.new gem, options
+
+    yield installer if block_given?
+
+    @spec = installer.install
+  end
+
+  ##
+  # Returns true if this specification is installable on this platform.
+
+  def installable_platform?
+    Gem::Platform.match spec.platform
+  end
+
+  def local? # :nodoc:
+    false
+  end
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/stats.rb b/jni/ruby/lib/rubygems/resolver/stats.rb
new file mode 100644
index 0000000..c31e5be
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/stats.rb
@@ -0,0 +1,44 @@
+class Gem::Resolver::Stats
+  def initialize
+    @max_depth = 0
+    @max_requirements = 0
+    @requirements = 0
+    @backtracking = 0
+    @iterations = 0
+  end
+
+  def record_depth(stack)
+    if stack.size > @max_depth
+      @max_depth = stack.size
+    end
+  end
+
+  def record_requirements(reqs)
+    if reqs.size > @max_requirements
+      @max_requirements = reqs.size
+    end
+  end
+
+  def requirement!
+    @requirements += 1
+  end
+
+  def backtracking!
+    @backtracking += 1
+  end
+
+  def iteration!
+    @iterations += 1
+  end
+
+  PATTERN = "%20s: %d\n"
+
+  def display
+    $stdout.puts "=== Resolver Statistics ==="
+    $stdout.printf PATTERN, "Max Depth", @max_depth
+    $stdout.printf PATTERN, "Total Requirements", @requirements
+    $stdout.printf PATTERN, "Max Requirements", @max_requirements
+    $stdout.printf PATTERN, "Backtracking #", @backtracking
+    $stdout.printf PATTERN, "Iteration #", @iterations
+  end
+end
diff --git a/jni/ruby/lib/rubygems/resolver/vendor_set.rb b/jni/ruby/lib/rubygems/resolver/vendor_set.rb
new file mode 100644
index 0000000..614bd05
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/vendor_set.rb
@@ -0,0 +1,87 @@
+##
+# A VendorSet represents gems that have been unpacked into a specific
+# directory that contains a gemspec.
+#
+# This is used for gem dependency file support.
+#
+# Example:
+#
+#   set = Gem::Resolver::VendorSet.new
+#
+#   set.add_vendor_gem 'rake', 'vendor/rake'
+#
+# The directory vendor/rake must contain an unpacked rake gem along with a
+# rake.gemspec (watching the given name).
+
+class Gem::Resolver::VendorSet < Gem::Resolver::Set
+
+  ##
+  # The specifications for this set.
+
+  attr_reader :specs # :nodoc:
+
+  def initialize # :nodoc:
+    super()
+
+    @directories = {}
+    @specs       = {}
+  end
+
+  ##
+  # Adds a specification to the set with the given +name+ which has been
+  # unpacked into the given +directory+.
+
+  def add_vendor_gem name, directory # :nodoc:
+    gemspec = File.join directory, "#{name}.gemspec"
+
+    spec = Gem::Specification.load gemspec
+
+    raise Gem::GemNotFoundException,
+          "unable to find #{gemspec} for gem #{name}" unless spec
+
+    spec.full_gem_path = File.expand_path directory
+
+    @specs[spec.name]  = spec
+    @directories[spec] = directory
+
+    spec
+  end
+
+  ##
+  # Returns an Array of VendorSpecification objects matching the
+  # DependencyRequest +req+.
+
+  def find_all req
+    @specs.values.select do |spec|
+      req.match? spec
+    end.map do |spec|
+      source = Gem::Source::Vendor.new @directories[spec]
+      Gem::Resolver::VendorSpecification.new self, spec, source
+    end
+  end
+
+  ##
+  # Loads a spec with the given +name+. +version+, +platform+ and +source+ are
+  # ignored.
+
+  def load_spec name, version, platform, source # :nodoc:
+    @specs.fetch name
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[VendorSet', ']' do
+      next if @directories.empty?
+      q.breakable
+
+      dirs = @directories.map do |spec, directory|
+        "#{spec.full_name}: #{directory}"
+      end
+
+      q.seplist dirs do |dir|
+        q.text dir
+      end
+    end
+  end
+
+end
+
diff --git a/jni/ruby/lib/rubygems/resolver/vendor_specification.rb b/jni/ruby/lib/rubygems/resolver/vendor_specification.rb
new file mode 100644
index 0000000..a99b5f3
--- /dev/null
+++ b/jni/ruby/lib/rubygems/resolver/vendor_specification.rb
@@ -0,0 +1,24 @@
+##
+# A VendorSpecification represents a gem that has been unpacked into a project
+# and is being loaded through a gem dependencies file through the +path:+
+# option.
+
+class Gem::Resolver::VendorSpecification < Gem::Resolver::SpecSpecification
+
+  def == other # :nodoc:
+    self.class === other and
+      @set  == other.set and
+      @spec == other.spec and
+      @source == other.source
+  end
+
+  ##
+  # This is a null install as this gem was unpacked into a directory.
+  # +options+ are ignored.
+
+  def install options = {}
+    yield nil
+  end
+
+end
+