rubygems-update 2.4.8 → 2.5.0

data/lib/rubygems/request/connection_pools.rb

@@ -61,18 +61,22 @@ class Gem::Request::ConnectionPools # :nodoc:
   end
 
   def net_http_args uri, proxy_uri
-    net_http_args = [uri.host, uri.port]
+    # URI::Generic#hostname was added in ruby 1.9.3, use it if exists, otherwise
+    # don't support IPv6 literals and use host.
+    hostname = uri.respond_to?(:hostname) ? uri.hostname : uri.host
+    net_http_args = [hostname, uri.port]
 
     no_proxy = get_no_proxy_from_env
 
-    if proxy_uri and not no_proxy?(uri.host, no_proxy) then
+    if proxy_uri and not no_proxy?(hostname, no_proxy) then
+      proxy_hostname = proxy_uri.respond_to?(:hostname) ? proxy_uri.hostname : proxy_uri.host
       net_http_args + [
-        proxy_uri.host,
+        proxy_hostname,
         proxy_uri.port,
         Gem::UriFormatter.new(proxy_uri.user).unescape,
         Gem::UriFormatter.new(proxy_uri.password).unescape,
       ]
-    elsif no_proxy? uri.host, no_proxy then
+    elsif no_proxy? hostname, no_proxy then
       net_http_args + [nil, nil]
     else
       net_http_args

data/lib/rubygems/request_set.rb

@@ -159,16 +159,13 @@ class Gem::RequestSet
 
       path = req.download cache_dir
 
-      inst = Gem::Installer.new path, options
+      inst = Gem::Installer.at path, options
 
       yield req, inst if block_given?
 
       requests << inst.install
     end
 
-    requests
-  ensure
-    raise if $!
     return requests if options[:gemdeps]
 
     specs = requests.map do |request|
@@ -187,6 +184,8 @@ class Gem::RequestSet
     Gem.done_installing_hooks.each do |hook|
       hook.call inst, specs
     end unless Gem.done_installing_hooks.empty?
+
+    requests
   end
 
   ##

data/lib/rubygems/request_set/gem_dependency_api.rb

@@ -174,7 +174,7 @@ class Gem::RequestSet::GemDependencyAPI
   ##
   # A Hash containing gem names and files to require from those gems.
 
-  attr_reader :requires # :nodoc:
+  attr_reader :requires
 
   ##
   # A set of gems that are loaded via the +:path+ option to #gem
@@ -396,7 +396,7 @@ Gem dependencies file #{@path} requires #{name} more than once.
   ##
   # Handles the git: option from +options+ for gem +name+.
   #
-  # Returns +true+ if the path option was handled.
+  # Returns +true+ if the gist or git option was handled.
 
   def gem_git name, options # :nodoc:
     if gist = options.delete(:gist) then

data/lib/rubygems/request_set/lockfile.rb

@@ -185,7 +185,7 @@ class Gem::RequestSet::Lockfile
 
     platforms = platforms.sort_by { |platform| platform.to_s }
 
-    platforms.sort.each do |platform|
+    platforms.each do |platform|
       out << "  #{platform}"
     end
 

data/lib/rubygems/request_set/lockfile/parser.rb

@@ -11,13 +11,13 @@ class Gem::RequestSet::Lockfile::Parser
 
   def parse
     until @tokens.empty? do
-      type, data, column, line = get
+      token = get
 
-      case type
+      case token.type
       when :section then
         @tokens.skip :newline
 
-        case data
+        case token.value
         when 'DEPENDENCIES' then
           parse_DEPENDENCIES
         when 'GIT' then
@@ -29,10 +29,10 @@ class Gem::RequestSet::Lockfile::Parser
         when 'PLATFORMS' then
           parse_PLATFORMS
         else
-          type, = get until @tokens.empty? or peek.first == :section
+          token = get until @tokens.empty? or peek.first == :section
         end
       else
-        raise "BUG: unhandled token #{type} (#{data.inspect}) at line #{line} column #{column}"
+        raise "BUG: unhandled token #{token.type} (#{token.value.inspect}) at line #{token.line} column #{token.column}"
       end
     end
   end
@@ -41,35 +41,33 @@ class Gem::RequestSet::Lockfile::Parser
   # Gets the next token for a Lockfile
 
   def get expected_types = nil, expected_value = nil # :nodoc:
-    current_token = @tokens.shift
+    token = @tokens.shift
 
-    type, value, column, line = current_token
+    if expected_types and not Array(expected_types).include? token.type then
+      unget token
 
-    if expected_types and not Array(expected_types).include? type then
-      unget current_token
-
-      message = "unexpected token [#{type.inspect}, #{value.inspect}], " +
+      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +
                 "expected #{expected_types.inspect}"
 
-      raise Gem::RequestSet::Lockfile::ParseError.new message, column, line, @filename
+      raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
     end
 
-    if expected_value and expected_value != value then
-      unget current_token
+    if expected_value and expected_value != token.value then
+      unget token
 
-      message = "unexpected token [#{type.inspect}, #{value.inspect}], " +
+      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +
                 "expected [#{expected_types.inspect}, " +
                 "#{expected_value.inspect}]"
 
-      raise Gem::RequestSet::Lockfile::ParseError.new message, column, line, @filename
+      raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
     end
 
-    current_token
+    token
   end
 
   def parse_DEPENDENCIES # :nodoc:
-    while not @tokens.empty? and :text == peek.first do
-      _, name, = get :text
+    while not @tokens.empty? and :text == peek.type do
+      token = get :text
 
       requirements = []
 
@@ -77,17 +75,17 @@ class Gem::RequestSet::Lockfile::Parser
       when :bang then
         get :bang
 
-        requirements << pinned_requirement(name)
+        requirements << pinned_requirement(token.value)
       when :l_paren then
         get :l_paren
 
         loop do
-          _, op,      = get :requirement
-          _, version, = get :text
+          op      = get(:requirement).value
+          version = get(:text).value
 
           requirements << "#{op} #{version}"
 
-          break unless peek[0] == :comma
+          break unless peek.type == :comma
 
           get :comma
         end
@@ -96,13 +94,13 @@ class Gem::RequestSet::Lockfile::Parser
 
         if peek[0] == :bang then
           requirements.clear
-          requirements << pinned_requirement(name)
+          requirements << pinned_requirement(token.value)
 
           get :bang
         end
       end
 
-      @set.gem name, *requirements
+      @set.gem token.value, *requirements
 
       skip :newline
     end
@@ -113,7 +111,7 @@ class Gem::RequestSet::Lockfile::Parser
 
     while [:entry, 'remote'] == peek.first(2) do
       get :entry, 'remote'
-      _, data, = get :text
+      data = get(:text).value
       skip :newline
 
       sources << Gem::Source.new(data)
@@ -128,8 +126,10 @@ class Gem::RequestSet::Lockfile::Parser
     set = Gem::Resolver::LockSet.new sources
     last_specs = nil
 
-    while not @tokens.empty? and :text == peek.first do
-      _, name, column, = get :text
+    while not @tokens.empty? and :text == peek.type do
+      token = get :text
+      name = token.value
+      column = token.column
 
       case peek[0]
       when :newline then
@@ -139,7 +139,9 @@ class Gem::RequestSet::Lockfile::Parser
       when :l_paren then
         get :l_paren
 
-        type, data, = get [:text, :requirement]
+        token = get [:text, :requirement]
+        type = token.type
+        data = token.value
 
         if type == :text and column == 4 then
           version, platform = data.split '-', 2
@@ -169,16 +171,17 @@ class Gem::RequestSet::Lockfile::Parser
 
   def parse_GIT # :nodoc:
     get :entry, 'remote'
-    _, repository, = get :text
+    repository = get(:text).value
 
     skip :newline
 
     get :entry, 'revision'
-    _, revision, = get :text
+    revision = get(:text).value
 
     skip :newline
 
-    type, value = peek.first 2
+    type = peek.type
+    value = peek.value
     if type == :entry and %w[branch ref tag].include? value then
       get
       get :text
@@ -195,8 +198,10 @@ class Gem::RequestSet::Lockfile::Parser
 
     last_spec = nil
 
-    while not @tokens.empty? and :text == peek.first do
-      _, name, column, = get :text
+    while not @tokens.empty? and :text == peek.type do
+      token = get :text
+      name = token.value
+      column = token.column
 
       case peek[0]
       when :newline then
@@ -204,7 +209,9 @@ class Gem::RequestSet::Lockfile::Parser
       when :l_paren then
         get :l_paren
 
-        type, data, = get [:text, :requirement]
+        token = get [:text, :requirement]
+        type = token.type
+        data = token.value
 
         if type == :text and column == 4 then
           last_spec = set.add_git_spec name, data, repository, revision, true
@@ -227,7 +234,7 @@ class Gem::RequestSet::Lockfile::Parser
 
   def parse_PATH # :nodoc:
     get :entry, 'remote'
-    _, directory, = get :text
+    directory = get(:text).value
 
     skip :newline
 
@@ -239,7 +246,9 @@ class Gem::RequestSet::Lockfile::Parser
     last_spec = nil
 
     while not @tokens.empty? and :text == peek.first do
-      _, name, column, = get :text
+      token = get :text
+      name = token.value
+      column = token.column
 
       case peek[0]
       when :newline then
@@ -247,7 +256,9 @@ class Gem::RequestSet::Lockfile::Parser
       when :l_paren then
         get :l_paren
 
-        type, data, = get [:text, :requirement]
+        token = get [:text, :requirement]
+        type = token.type
+        data = token.value
 
         if type == :text and column == 4 then
           last_spec = set.add_vendor_gem name, directory
@@ -270,7 +281,7 @@ class Gem::RequestSet::Lockfile::Parser
 
   def parse_PLATFORMS # :nodoc:
     while not @tokens.empty? and :text == peek.first do
-      _, name, = get :text
+      name = get(:text).value
 
       @platforms << name
 
@@ -285,14 +296,14 @@ class Gem::RequestSet::Lockfile::Parser
   def parse_dependency name, op # :nodoc:
     return Gem::Dependency.new name, op unless peek[0] == :text
 
-    _, version, = get :text
+    version = get(:text).value
 
     requirements = ["#{op} #{version}"]
 
-    while peek[0] == :comma do
+    while peek.type == :comma do
       get :comma
-      _, op,      = get :requirement
-      _, version, = get :text
+      op      = get(:requirement).value
+      version = get(:text).value
 
       requirements << "#{op} #{version}"
     end

data/lib/rubygems/request_set/lockfile/tokenizer.rb

@@ -2,6 +2,9 @@ require 'strscan'
 require 'rubygems/request_set/lockfile/parser'
 
 class Gem::RequestSet::Lockfile::Tokenizer
+  Token = Struct.new :type, :value, :column, :line
+  EOF   = Token.new :EOF
+
   def self.from_file file
     new File.read(file), file
   end
@@ -19,11 +22,11 @@ class Gem::RequestSet::Lockfile::Tokenizer
   end
 
   def to_a
-    @tokens
+    @tokens.map { |token| [token.type, token.value, token.column, token.line] }
   end
 
   def skip type
-    @tokens.shift while not @tokens.empty? and peek.first == type
+    @tokens.shift while not @tokens.empty? and peek.type == type
   end
 
   ##
@@ -48,7 +51,7 @@ class Gem::RequestSet::Lockfile::Tokenizer
   alias :shift :next_token
 
   def peek
-    @tokens.first || [:EOF]
+    @tokens.first || EOF
   end
 
   private
@@ -71,7 +74,7 @@ class Gem::RequestSet::Lockfile::Tokenizer
       @tokens <<
         case
         when s.scan(/\r?\n/) then
-          token = [:newline, nil, *token_pos(pos)]
+          token = Token.new(:newline, nil, *token_pos(pos))
           @line_pos = s.pos
           @line += 1
           token
@@ -79,25 +82,25 @@ class Gem::RequestSet::Lockfile::Tokenizer
           if leading_whitespace then
             text = s.matched
             text += s.scan(/[^\s)]*/).to_s # in case of no match
-            [:text, text, *token_pos(pos)]
+            Token.new(:text, text, *token_pos(pos))
           else
-            [:section, s.matched, *token_pos(pos)]
+            Token.new(:section, s.matched, *token_pos(pos))
           end
         when s.scan(/([a-z]+):\s/) then
           s.pos -= 1 # rewind for possible newline
-          [:entry, s[1], *token_pos(pos)]
+          Token.new(:entry, s[1], *token_pos(pos))
         when s.scan(/\(/) then
-          [:l_paren, nil, *token_pos(pos)]
+          Token.new(:l_paren, nil, *token_pos(pos))
         when s.scan(/\)/) then
-          [:r_paren, nil, *token_pos(pos)]
+          Token.new(:r_paren, nil, *token_pos(pos))
         when s.scan(/<=|>=|=|~>|<|>|!=/) then
-          [:requirement, s.matched, *token_pos(pos)]
+          Token.new(:requirement, s.matched, *token_pos(pos))
         when s.scan(/,/) then
-          [:comma, nil, *token_pos(pos)]
+          Token.new(:comma, nil, *token_pos(pos))
         when s.scan(/!/) then
-          [:bang, nil, *token_pos(pos)]
+          Token.new(:bang, nil, *token_pos(pos))
         when s.scan(/[^\s),!]*/) then
-          [:text, s.matched, *token_pos(pos)]
+          Token.new(:text, s.matched, *token_pos(pos))
         else
           raise "BUG: can't create token for: #{s.string[s.pos..-1].inspect}"
         end

data/lib/rubygems/resolver.rb

@@ -1,5 +1,6 @@
 require 'rubygems/dependency'
 require 'rubygems/exceptions'
+require 'rubygems/util'
 require 'rubygems/util/list'
 
 require 'uri'
@@ -12,6 +13,7 @@ require 'net/http'
 # all the requirements.
 
 class Gem::Resolver
+  require 'rubygems/resolver/molinillo'
 
   ##
   # If the DEBUG_RESOLVER environment variable is set then debugging mode is
@@ -20,13 +22,6 @@ class Gem::Resolver
 
   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.
 
@@ -110,7 +105,6 @@ class Gem::Resolver
     @set = set || Gem::Resolver::IndexSet.new
     @needed = needed
 
-    @conflicts           = []
     @development         = false
     @development_shallow = false
     @ignore_dependencies = false
@@ -153,7 +147,7 @@ class Gem::Resolver
     return spec, activation_request
   end
 
-  def requests s, act, reqs=nil # :nodoc:
+  def requests s, act, reqs=[] # :nodoc:
     return reqs if @ignore_dependencies
 
     s.fetch_development_dependencies if @development
@@ -165,7 +159,7 @@ class Gem::Resolver
       next if d.type == :development and @development_shallow and
               act.parent
 
-      reqs.add Gem::Resolver::DependencyRequest.new(d, act)
+      reqs << Gem::Resolver::DependencyRequest.new(d, act)
       @stats.requirement!
     end
 
@@ -176,29 +170,29 @@ class Gem::Resolver
     reqs
   end
 
-  ##
-  # Proceed with resolution! Returns an array of ActivationRequest objects.
-
-  def resolve
-    @conflicts = []
-
-    needed = Gem::Resolver::RequirementList.new
+  include Molinillo::UI
 
-    @needed.reverse_each do |n|
-      request = Gem::Resolver::DependencyRequest.new n, nil
-
-      needed.add request
-      @stats.requirement!
-    end
+  def output
+    @output ||= debug? ? $stdout : File.open(Gem::Util::NULL_DEVICE, 'w')
+  end
 
-    @stats.record_requirements needed
+  def debug?
+    DEBUG_RESOLVER
+  end
 
-    res = resolve_for needed, nil
+  include Molinillo::SpecificationProvider
 
-    raise Gem::DependencyResolutionError, res if
-      res.kind_of? Gem::Resolver::Conflict
+  ##
+  # Proceed with resolution! Returns an array of ActivationRequest objects.
 
-    res.to_a
+  def resolve
+    locking_dg = Molinillo::DependencyGraph.new
+    Molinillo::Resolver.new(self, self).resolve(@needed.map { |d| DependencyRequest.new d, nil }, locking_dg).tsort.map(&:payload)
+  rescue Molinillo::VersionConflict => e
+    conflict = e.conflicts.values.first
+    raise Gem::DependencyResolutionError, Conflict.new(conflict.requirement_trees.first.first, conflict.existing, conflict.requirement)
+  ensure
+    @output.close if @output and !debug?
   end
 
   ##
@@ -221,232 +215,44 @@ class Gem::Resolver
     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
+  # Returns the gems in +specs+ that match the local platform.
 
-      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
+  def select_local_platforms specs # :nodoc:
+    specs.select do |spec|
+      Gem::Platform.installable? spec
     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]
+  def search_for(dependency)
+    possibles, all = find_possible(dependency)
+    if !@soft_missing && possibles.empty?
+      @missing << dependency
+      exc = Gem::UnsatisfiableDependencyError.new dependency, all
+      exc.errors = @set.errors
+      raise exc
     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
+    possibles.sort_by { |s| [s.source, s.version, s.platform == Gem::Platform.local.to_s ? 1 : 0] }.
+      map { |s| ActivationRequest.new s, dependency, [] }
   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
+  def dependencies_for(specification)
+    return [] if @ignore_dependencies
+    spec = specification.spec
+    requests(spec, specification)
   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
+  def requirement_satisfied_by?(requirement, activated, spec)
+    requirement.matches_spec? spec
   end
 
-  ##
-  # Returns the gems in +specs+ that match the local platform.
+  def name_for(dependency)
+    dependency.name
+  end
 
-  def select_local_platforms specs # :nodoc:
-    specs.select do |spec|
-      Gem::Platform.installable? spec
-    end
+  def allow_missing?(dependency)
+    @missing << dependency
+    @soft_missing
   end
 
 end
@@ -482,4 +288,3 @@ require 'rubygems/resolver/installed_specification'
 require 'rubygems/resolver/local_specification'
 require 'rubygems/resolver/lock_specification'
 require 'rubygems/resolver/vendor_specification'
-