bundler 1.8.9 → 1.9.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ddf096e691d8e5cc1625221906686441b6d48d45
-  data.tar.gz: 0b899a722320c9828c1980fcc19838ba6f7cfe2c
+  metadata.gz: 86a33559b397d9ddda95f691097fa4811d9a9c12
+  data.tar.gz: f93e41d2292a01daa7566fc9ab92ce80441dd543
 SHA512:
-  metadata.gz: 41d1b08f9febdc290c8b99c3fe7a37f4d7a7431c989f9fb141212d3f08b6b11348f8b5f60c71fd23e1f98677f59f7b5ffe4cbcb0f96506cce93965940f87e045
-  data.tar.gz: ceb61499c262ea1ab1282d80f70322d36d12880dbcb11d5af528383d0b26a301afed9f59863fe926e29627fd7761d3aa7cf2c1cbffbdad9c9ea10b0e3f82016e
+  metadata.gz: f97a40fcec05c571ce3d189aa40dd94293f14b39fb3cf14ccb71e1dee73b17300234010b5ca13903eba84620e3afa5f95eb9d8e527607bf8c4cb1d7988a20fcc
+  data.tar.gz: 1c9aa9f983791d29fb606d85d5ab3d5048c0fbc92d5eb01cb3c8ba9ffcd33529d773a22c660582166aa99dc6cc32ae86233e7963ed7c7d8756d2114931adcfa2

data/.travis.yml

@@ -27,6 +27,7 @@ notifications:
       - secure: JxBi7DDJGkIF/7f/FSN/HUHpvV4EKfQccZHTPd1b2pNJn3GXo6u+tNVbAw2WjxYzPyPQI3ZcYBCU9SEXp/i7VmG8uMzh8Kyildw+miSKYKVb90uYqcsXWzbxwyNBgJLvyDkzST45H5lgnyAicee3WkFes/WDZikIajbH7ztdb04=
 
 rvm:
+  - 2.2
   - 2.1
   - 2.0.0
   - 1.9.3
@@ -38,24 +39,25 @@ env:
   # We need to know if changes to rubygems will break bundler on release
   - RGV=master
   # Test the latest rubygems release with all of our supported rubies
-  - RGV=v2.4.4
+  - RGV=v2.4.6
 
 matrix:
   fast_finish: true
   include:
+    # Ruby 2.2, Rubygems 2.4.5 and up (RG 2.4 is included by the matrix above)
     # Ruby 2.1, Rubygems 2.2.2 and up
     - rvm: 2.1
-      env: RGV=v2.2.2
-    # Ruby 2.0.0, Rubygems 2.0 and up
+      env: RGV=v2.2.3
+    # Ruby 2.0.0, Rubygems 2.0.0 and up
     - rvm: 2.0.0
-      env: RGV=v2.2.2
+      env: RGV=v2.2.3
     - rvm: 2.0.0
       env: RGV=v2.1.11
     - rvm: 2.0.0
       env: RGV=v2.0.14
     # Ruby 1.9.3, Rubygems 1.5.3 and up
     - rvm: 1.9.3
-      env: RGV=v2.2.2
+      env: RGV=v2.2.3
     - rvm: 1.9.3
       env: RGV=v2.1.11
     - rvm: 1.9.3
@@ -70,7 +72,7 @@ matrix:
       env: RGV=v1.5.3
     # Ruby 1.8.7, Rubygems 1.3.6 and up
     - rvm: 1.8.7
-      env: RGV=v2.2.2
+      env: RGV=v2.2.3
     - rvm: 1.8.7
       env: RGV=v2.0.14
     - rvm: 1.8.7
@@ -95,7 +97,7 @@ matrix:
     # Ruby 1.9.2 sanity check
     # (but it's just too slow and sometimes goes over the Travis limit)
     - rvm: 1.9.2
-      env: RGV=v2.3.0
+      env: RGV=v2.4.6
     # Ruby-head (we want to know how we're doing, but not fail the build)
     - rvm: ruby-head
       env: RGV=master

data/CHANGELOG.md

@@ -1,27 +1,14 @@
-## 1.8.9 (2015-05-02)
+## 1.9.0.pre (2015-03-11)
 
-Bugfixes:
-
-  - Support RubyGems versions above 2.4.6 (@tenderlove, @segiddins, @indirect)
-
-## 1.8.8 (2015-04-29)
-
-Bugfixes:
-
-  - Respect Gemfile sources when installing a gem present in two sources (#3585, @tmoore)
-
-## 1.8.7 (2015-04-07)
-
-Bugfixes:
-
-  - stop suppressing errors inside gems that get required (#3549, @indirect)
+Features:
 
-## 1.8.6 (2015-03-30)
+  - prefer gemspecs closest to the directory root (#3428, @segiddins)
+  - debug log for API request limits (#3452, @neerfri)
 
-Bugfixes:
+"Features":
 
-  - keep gems locked when updating another gem from the same source (#3250, @indirect)
-  - resolve race that could build gems without saved arguments (#3404, @indirect)
+  - Molinillo resolver, shared with CocoaPods (@segiddins)
+  - updated Thor to v0.19.1 (@segiddins)
 
 ## 1.8.5 (2015-03-11)
 
@@ -109,6 +96,7 @@ Features:
   - add `package --cache-path` and `config cache_path` for cache location (@jnraine)
   - allow `config` to work even when a Gemfile is not present (@dholdren)
   - add `config gemfile /path` for other Gemfile locations (@dholdren)
+  - add `github` method alonside the `git` method (@BenMorganIO)
 
 Bugfixes:
 
@@ -121,19 +109,6 @@ Documentation:
 
   - add missing Gemfile global `path` explanation (@agenteo)
 
-## 1.7.15 (2015-04-29)
-
-Bugfixes:
-
-  - Respect Gemfile sources when installing a gem present in two sources (#3585, @tmoore)
-
-## 1.7.14 (2015-03-30)
-
-Bugfixes:
-
-  - Keep gems locked when updating another gem from the same source (#3250, @indirect)
-  - Don't add extra quotes around long, quoted config values (@aroben, #3338)
-
 ## 1.7.13 (2015-02-07)
 
 Bugfixes:

data/Rakefile

@@ -27,6 +27,52 @@ module Rake
   end
 end
 
+namespace :molinillo do
+  task :namespace do
+    files = Dir.glob('lib/bundler/vendor/Molinillo*/**/*.rb')
+    sh "sed -i.bak 's/Molinillo/Bundler::Molinillo/g' #{files.join(' ')}"
+    sh "rm #{files.join('.bak ')}.bak"
+  end
+
+  task :clean do
+    files = Dir.glob('lib/bundler/vendor/Molinillo*/*', File::FNM_DOTMATCH).reject { |f| %(. .. lib).include? f.split('/').last }
+    puts files
+    sh "rm -r #{files.join(' ')}"
+  end
+
+  task :update, [:tag] => [] do |t, args|
+    tag = args[:tag]
+    Dir.chdir 'lib/bundler/vendor' do
+      `curl -L https://github.com/CocoaPods/molinillo/archive/#{tag}.tar.gz | tar -xz`
+    end
+    Rake::Task['molinillo:namespace'].invoke
+    Rake::Task['molinillo:clean'].invoke
+  end
+end
+
+namespace :thor do
+  task :namespace do
+    files = Dir.glob('lib/bundler/vendor/thor*/**/*.rb')
+    sh "sed -i.bak 's/Thor/Bundler::Thor/g' #{files.join(' ')}"
+    sh "rm #{files.join('.bak ')}.bak"
+  end
+
+  task :clean do
+    files = Dir.glob('lib/bundler/vendor/thor*/*', File::FNM_DOTMATCH).reject { |f| %(. .. lib).include? f.split('/').last }
+    puts files
+    sh "rm -r #{files.join(' ')}"
+  end
+
+  task :update, [:tag] => [] do |t, args|
+    tag = args[:tag]
+    Dir.chdir 'lib/bundler/vendor' do
+      `curl -L https://github.com/erikhuda/thor/archive/#{tag}.tar.gz | tar -xz`
+    end
+    Rake::Task['thor:namespace'].invoke
+    Rake::Task['thor:clean'].invoke
+  end
+end
+
 namespace :spec do
   desc "Ensure spec dependencies are installed"
   task :deps do
@@ -111,8 +157,8 @@ begin
     namespace :rubygems do
       rubyopt = ENV["RUBYOPT"]
       # When editing this list, also edit .travis.yml!
-      branches = %w(master 2.2)
-      releases = %w(v1.3.6 v1.3.7 v1.4.2 v1.5.3 v1.6.2 v1.7.2 v1.8.29 v2.0.14 v2.1.11 v2.2.2 v2.4.4)
+      branches = %w(master)
+      releases = %w(v1.3.6 v1.3.7 v1.4.2 v1.5.3 v1.6.2 v1.7.2 v1.8.29 v2.0.14 v2.1.11 v2.2.3 v2.4.6)
       (branches + releases).each do |rg|
         desc "Run specs with Rubygems #{rg}"
         RSpec::Core::RakeTask.new(rg) do |t|
@@ -234,15 +280,12 @@ begin
     task :clean do
       rm_rf "lib/bundler/man"
     end
-
-    task(:require) { }
   end
 
 rescue LoadError
   namespace :man do
-    task(:require) { abort "Install the ronn gem to be able to release!" }
-    task(:build) { warn "Install the ronn gem to build the help pages" }
-    task(:clean) { }
+    task(:build) { warn "Install the ronn gem to be able to release!" }
+    task(:clean) { warn "Install the ronn gem to be able to release!" }
   end
 end
 
@@ -254,6 +297,6 @@ end
 
 require 'bundler/gem_tasks'
 task :build => ["man:clean", "man:build"]
-task :release => ["man:require", "man:clean", "man:build"]
+task :release => ["man:clean", "man:build"]
 
 task :default => :spec

data/lib/bundler/cli/gem.rb

@@ -37,8 +37,10 @@ module Bundler
         :email            => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
         :test             => options[:test],
         :ext              => options[:ext],
-        :bin              => options[:bin]
+        :bin              => options[:bin],
+        :bundler_version  => bundler_dependency_version
       }
+      ensure_safe_gem_name(opts[:name], opts[:constant_array])
 
       templates = {
         "Gemfile.tt" => "Gemfile",
@@ -161,5 +163,22 @@ module Bundler
       test_framework
     end
 
+    def bundler_dependency_version
+      v = Gem::Version.new(Bundler::VERSION)
+      req = v.segments[0..1]
+      req << v.segments.last if v.prerelease?
+      req.join(".")
+    end
+
+    def ensure_safe_gem_name name, constant_array
+      if name =~ /^\d/
+        Bundler.ui.error "Invalid gem name #{name} Please give a name which does not start with numbers."
+        exit 1
+      elsif Object.const_defined?(constant_array.first)
+        Bundler.ui.error "Invalid gem name #{name} constant #{constant_array.join("::")} is already in use. Please choose another gem name."
+        exit 1
+      end
+    end
+
   end
 end

data/lib/bundler/cli/install.rb

@@ -2,7 +2,7 @@ module Bundler
   class CLI::Install
     attr_reader :options
     def initialize(options)
-      @options = options.dup
+      @options = options
     end
 
     def run

data/lib/bundler/definition.rb

@@ -184,10 +184,11 @@ module Bundler
     # @return [SpecSet] resolved dependencies
     def resolve
       @resolve ||= begin
-        last_resolve = converge_locked_specs
         if Bundler.settings[:frozen] || (!@unlocking && nothing_changed?)
-          last_resolve
+          @locked_specs
         else
+          last_resolve = converge_locked_specs
+
           # Run a resolve against the locally available gems
           last_resolve.merge Resolver.resolve(expanded_dependencies, index, source_requirements, last_resolve)
         end
@@ -271,7 +272,7 @@ module Bundler
           each do |spec|
             next if spec.name == 'bundler'
             out << spec.to_lock
-          end
+        end
         out << "\n"
       end
 
@@ -520,9 +521,7 @@ module Bundler
 
       converged = []
       @locked_specs.each do |s|
-        # Replace the locked dependency's source with the equivalent source from the Gemfile
-        dep = @dependencies.find { |d| s.satisfies?(d) }
-        s.source = (dep && dep.source) || sources.get(s.source)
+        s.source = sources.get(s.source)
 
         # Don't add a spec to the list if its source is expired. For example,
         # if you change a Git gem to Rubygems.
@@ -562,15 +561,12 @@ module Bundler
       resolve
     end
 
-    def in_locked_deps?(dep, locked_dep)
-      # Because the lockfile can't link a dep to a specific remote, we need to
-      # treat sources as equivalent anytime the locked dep has all the remotes
-      # that the Gemfile dep does.
-      locked_dep && locked_dep.source && dep.source && locked_dep.source.include?(dep.source)
+    def in_locked_deps?(dep, d)
+      d && dep.source == d.source
     end
 
     def satisfies_locked_spec?(dep)
-      @locked_specs.any? { |s| s.satisfies?(dep) && (!dep.source || s.source.include?(dep.source)) }
+      @locked_specs.any? { |s| s.satisfies?(dep) && (!dep.source || s.source == dep.source) }
     end
 
     def expanded_dependencies

data/lib/bundler/dep_proxy.rb

@@ -1,10 +1,10 @@
 module Bundler
   class DepProxy
 
-    attr_reader :required_by, :__platform, :dep
+    attr_reader :__platform, :dep
 
     def initialize(dep, platform)
-      @dep, @__platform, @required_by = dep, platform, []
+      @dep, @__platform = dep, platform
     end
 
     def hash

data/lib/bundler/installer.rb

@@ -96,26 +96,20 @@ module Bundler
 
     def install_gem_from_spec(spec, standalone = false, worker = 0)
       # Fetch the build settings, if there are any
-      settings = Bundler.settings["build.#{spec.name}"]
-      messages = nil
-
-      if settings
-        Bundler.rubygems.with_build_args [settings] do
-          messages = spec.source.install(spec)
+      settings             = Bundler.settings["build.#{spec.name}"]
+      install_message      = nil
+      post_install_message = nil
+      debug_message        = nil
+      Bundler.rubygems.with_build_args [settings] do
+        install_message, post_install_message, debug_message = spec.source.install(spec)
+        if install_message.include? 'Installing'
+          Bundler.ui.confirm install_message
+        else
+          Bundler.ui.info install_message
         end
-      else
-        messages = spec.source.install(spec)
-      end
-
-      install_message, post_install_message, debug_message = *messages
-
-      if install_message.include? 'Installing'
-        Bundler.ui.confirm install_message
-      else
-        Bundler.ui.info install_message
+        Bundler.ui.debug debug_message if debug_message
+        Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
       end
-      Bundler.ui.debug debug_message if debug_message
-      Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
 
       if Bundler.settings[:bin] && standalone
         generate_standalone_bundler_executable_stubs(spec)

data/lib/bundler/resolver.rb

@@ -1,27 +1,73 @@
 require 'set'
+
 # This is the latest iteration of the gem dependency resolving algorithm. As of now,
 # it can resolve (as a success or failure) any set of gem dependencies we throw at it
 # in a reasonable amount of time. The most iterations I've seen it take is about 150.
 # The actual implementation of the algorithm is not as good as it could be yet, but that
 # can come later.
 
-# Extending Gem classes to add necessary tracking information
-module Gem
-  class Specification
-    def required_by
-      @required_by ||= []
-    end
-  end
-  class Dependency
-    def required_by
-      @required_by ||= []
-    end
-  end
-end
-
 module Bundler
   class Resolver
 
+    require 'bundler/vendored_molinillo'
+
+    class Molinillo::VersionConflict
+      def clean_req(req)
+        if req.to_s.include?(">= 0")
+          req.to_s.gsub(/ \(.*?\)$/, '')
+        else
+          req.to_s.gsub(/\, (runtime|development)\)$/, ')')
+        end
+      end
+
+      def message
+        conflicts.values.flatten.reduce('') do |o, conflict|
+          o << %(Bundler could not find compatible versions for gem "#{conflict.requirement.name}":\n)
+          if conflict.locked_requirement
+            o << %(  In snapshot (Gemfile.lock):\n)
+            o << %(    #{clean_req conflict.locked_requirement}\n)
+            o << %(\n)
+          end
+          o << %(  In Gemfile:\n)
+          o << conflict.requirement_trees.map do |tree|
+            t = ''
+            depth = 2
+            tree.each do |req|
+              t << '  ' * depth << %(#{clean_req req})
+              t << %( depends on) unless tree[-1] == req
+              t << %(\n)
+              depth += 1
+            end
+            t
+          end.join("\n")
+
+          if conflict.requirement.name == 'bundler'
+            o << %(\n  Current Bundler version:\n    bundler (#{Bundler::VERSION}))
+            other_bundler_required = !conflict.requirement.requirement.satisfied_by?(Gem::Version.new Bundler::VERSION)
+          end
+
+          if conflict.requirement.name == "bundler" && other_bundler_required
+            o << "\n"
+            o << "This Gemfile requires a different version of Bundler.\n"
+            o << "Perhaps you need to update Bundler by running `gem install bundler`?\n"
+          end
+          if conflict.locked_requirement
+            o << "\n"
+            o << %(Running `bundle update` will rebuild your snapshot from scratch, using only\n)
+            o << %(the gems in your Gemfile, which may resolve the conflict.\n)
+          elsif !conflict.existing
+            if conflict.requirement_trees.first.size > 1
+              o << "Could not find gem '#{clean_req(conflict.requirement)}', which is required by "
+              o << "gem '#{clean_req(conflict.requirement_trees.first[-2])}', in any of the sources."
+            else
+              o << "Could not find gem '#{clean_req(conflict.requirement)} in any of the sources\n"
+            end
+          end
+          o
+        end
+      end
+    end
+
     ALL = Bundler::Dependency::PLATFORM_MAP.values.uniq.freeze
 
     class SpecGroup < Array
@@ -65,8 +111,10 @@ module Bundler
 
       def activate_platform(platform)
         unless @activated.include?(platform)
-          @activated << platform
-          return __dependencies[platform] || []
+          if for?(platform)
+            @activated << platform
+            return __dependencies[platform] || []
+          end
         end
         []
       end
@@ -91,6 +139,14 @@ module Bundler
         "#{name} (#{version})"
       end
 
+      def dependencies_for_activated_platforms
+        @activated.map { |p| __dependencies[p] }.flatten
+      end
+
+      def platforms_for_dependency_named(dependency)
+        __dependencies.select { |p, deps| deps.map(&:name).include? dependency }.keys
+      end
+
     private
 
       def __dependencies
@@ -110,8 +166,6 @@ module Bundler
       end
     end
 
-    attr_reader :errors, :started_at, :iteration_rate, :iteration_counter, :initial_reqs
-
     # Figures out the best possible configuration of gems that satisfies
     # the list of passed dependencies and any child dependencies without
     # causing any gem activation errors.
@@ -123,289 +177,85 @@ module Bundler
     # <GemBundle>,nil:: If the list of dependencies can be resolved, a
     #   collection of gemspecs is returned. Otherwise, nil is returned.
     def self.resolve(requirements, index, source_requirements = {}, base = [])
-      Bundler.ui.info "Resolving dependencies...", false
       base = SpecSet.new(base) unless base.is_a?(SpecSet)
       resolver = new(index, source_requirements, base)
       result = resolver.start(requirements)
-      Bundler.ui.info "" # new line now that dots are done
       SpecSet.new(result)
-    rescue => e
-      Bundler.ui.info "" # new line before the error
-      raise e
-    end
-
-    def initialize(index, source_requirements, base)
-      @initial_reqs         = []
-      @errors               = {}
-      @base                 = base
-      @index                = index
-      @deps_for             = {}
-      @missing_gems         = Hash.new(0)
-      @prereleases_cache    = Hash.new { |h,k| h[k] = k.prerelease? }
-      @source_requirements  = source_requirements
-      @iteration_counter    = 0
-      @started_at           = Time.now
     end
 
-    def debug
-      if ENV['DEBUG_RESOLVER']
-        debug_info = yield
-        debug_info = debug_info.inspect unless debug_info.is_a?(String)
-        $stderr.puts debug_info
-      end
-    end
 
-    def successify(activated)
-      activated.values.map { |s| s.to_specs }.flatten.compact
-    end
-
-    def start(reqs, current_traversal=false)
-      @initial_reqs = reqs.dup unless current_traversal
-      activated = {}
-      @gems_size = Hash[reqs.map { |r| [r, gems_size(r)] }]
-
-      resolve(reqs, activated, current_traversal)
+    def initialize(index, source_requirements, base)
+      @index = index
+      @source_requirements = source_requirements
+      @base = base
+      @resolver = Molinillo::Resolver.new(self, self)
+      @search_for = {}
+      @prereleases_cache = Hash.new { |h,k| h[k] = k.prerelease? }
+      @base_dg = Molinillo::DependencyGraph.new
+      @base.each { |ls| @base_dg.add_root_vertex ls.name, Dependency.new(ls.name, ls.version) }
     end
 
-    class State < Struct.new(:reqs, :activated, :requirement, :possibles, :depth, :conflicts)
-      def name
-        requirement.name
-      end
+    def start(requirements)
+      verify_gemfile_dependencies_are_found!(requirements)
+      dg = @resolver.resolve(requirements, @base_dg)
+      dg.map(&:payload).map(&:to_specs).flatten
+    rescue Molinillo::VersionConflict => e
+      raise VersionConflict.new(e.conflicts.keys.uniq, e.message)
+    rescue Molinillo::CircularDependencyError => e
+      names = e.dependencies.sort_by(&:name).map { |d| "gem '#{d.name}'"}
+      raise CyclicDependencyError, "Your Gemfile requires gems that depend" \
+        " on each other, creating an infinite loop. Please remove" \
+        " #{names.count > 1 ? 'either ' : '' }#{names.join(' or ')}" \
+        " and try again."
     end
 
-    def handle_conflict(current, states, existing=nil)
-      until current.nil?
-        current_state = find_state(current, states)
-        return current if state_any?(current_state)
-        current = current.required_by.last if current
-      end
+    include Molinillo::UI
 
-      until existing.nil?
-        existing_state = find_state(existing, states)
-        return existing if state_any?(existing_state)
-        existing = existing.required_by.last if existing
+    # Conveys debug information to the user.
+    #
+    # @param [Integer] depth the current depth of the resolution process.
+    # @return [void]
+    def debug(depth = 0)
+      if debug?
+        debug_info = yield
+        debug_info = debug_info.inspect unless debug_info.is_a?(String)
+        STDERR.puts debug_info.split("\n").map { |s| '  ' * depth + s }
       end
     end
 
-    def state_any?(state)
-      state && state.possibles.any?
+    def debug?
+      ENV['DEBUG_RESOLVER'] || ENV['DEBUG_RESOLVER_TREE']
     end
 
-    def find_state(current, states)
-      states.detect { |i| current && current.name == i.name }
+    def before_resolution
+      Bundler.ui.info 'Resolving dependencies...', false
     end
 
-    def other_possible?(conflict, states)
-      return unless conflict
-      state = states.detect { |i| i.name == conflict.name }
-      state && state.possibles.any?
+    def after_resolution
+      Bundler.ui.info ''
     end
 
-    def find_conflict_state(conflict, states)
-      return unless conflict
-      until states.empty? do
-        state = states.pop
-        return state if conflict.name == state.name
-      end
-    end
-
-    def activate_gem(reqs, activated, requirement, current)
-      requirement.required_by.replace current.required_by
-      requirement.required_by << current
-      activated[requirement.name] = requirement
-
-      debug { "  Activating: #{requirement.name} (#{requirement.version})" }
-      debug { requirement.required_by.map { |d| "    * #{d.name} (#{d.requirement})" }.join("\n") }
-
-      dependencies = requirement.activate_platform(current.__platform)
-
-      debug { "    Dependencies"}
-      dependencies.each do |dep|
-        next if dep.type == :development
-        dep.required_by.replace(current.required_by)
-        dep.required_by << current
-        @gems_size[dep] ||= gems_size(dep)
-        reqs << dep
-      end
-    end
-
-    def resolve_for_conflict(state)
-      return version_conflict if state.nil? || state.possibles.empty?
-      reqs, activated, depth, conflicts = state.reqs.dup, state.activated.dup, state.depth, state.conflicts.dup
-      requirement = state.requirement
-      possible = state.possibles.pop
-
-      activate_gem(reqs, activated, possible, requirement)
-
-      return reqs, activated, depth, conflicts
+    def indicate_progress
+      Bundler.ui.info '.', false
     end
 
-    def resolve_conflict(current, states)
-      # Find the state where the conflict has occurred
-      state = find_conflict_state(current, states)
-
-      debug { "    -> Going to: #{current.name} state" } if current
-
-      # Resolve the conflicts by rewinding the state
-      # when the conflicted gem was activated
-      reqs, activated, depth, conflicts = resolve_for_conflict(state)
+    private
 
-      # Keep the state around if it still has other possibilities
-      states << state unless state.possibles.empty?
-      clear_search_cache
+    include Molinillo::SpecificationProvider
 
-      return reqs, activated, depth, conflicts
+    def dependencies_for(specification)
+      specification.dependencies_for_activated_platforms
     end
 
-    def resolve(reqs, activated, current_traversal)
-      states = []
-      depth = 0
-      conflicts = Set.new
-
-      until reqs.empty?
-
-        indicate_progress
-
-        debug { print "\e[2J\e[f" ; "==== Iterating ====\n\n" }
-
-        reqs = reqs.sort_by do |a|
-          [ activated[a.name] ? 0 : 1,
-            @prereleases_cache[a.requirement] ? 0 : 1,
-            @errors[a.name]   ? 0 : 1,
-            activated[a.name] ? 0 : @gems_size[a] ]
-        end
-
-        debug { "Activated:\n" + activated.values.map {|a| "  #{a}" }.join("\n") }
-        debug { "Requirements:\n" + reqs.map {|r| "  #{r}"}.join("\n") }
-
-        current = reqs.shift
-
-        $stderr.puts "#{' ' * depth}#{current}" if ENV['DEBUG_RESOLVER_TREE']
-
-        debug { "Attempting:\n  #{current}"}
-
-        existing = activated[current.name]
-
-
-        if existing || current.name == 'bundler'
-          # Force the current
-          if current.name == 'bundler' && !existing
-            existing = search(DepProxy.new(Gem::Dependency.new('bundler', VERSION), Gem::Platform::RUBY)).first
-            raise GemNotFound, %Q{Bundler could not find gem "bundler" (#{VERSION})} unless existing
-            existing.required_by << existing
-            activated['bundler'] = existing
-          end
-
-          if current.requirement.satisfied_by?(existing.version)
-            debug { "    * [SUCCESS] Already activated" }
-            @errors.delete(existing.name)
-            dependencies = existing.activate_platform(current.__platform)
-            reqs.concat dependencies
-
-            dependencies.each do |dep|
-              next if dep.type == :development
-              @gems_size[dep] ||= gems_size(dep)
-            end
-
-            depth += 1
-            next
-          else
-            debug { "    * [FAIL] Already activated" }
-            @errors[existing.name] = [existing, current]
-
-            conflicts << current.name
-
-            parent = current.required_by.last
-
-            if current_traversal
-              parent = handle_conflict(current, states)
-            else
-              parent = handle_conflict(parent, states)
-            end
-
-
-            if parent.nil? && !conflicts.empty?
-              parent = states.reverse.detect { |i| conflicts.include?(i.name) && state_any?(i)}
-            end
-
-            if existing.respond_to?(:required_by)
-              parent = handle_conflict(parent, states, existing.required_by[-2]) unless other_possible?(parent, states)
-            end
-
-            return version_conflict(current_traversal) if parent.nil? || parent.name == 'bundler'
-
-            reqs, activated, depth, conflicts = resolve_conflict(parent, states)
-          end
-        else
-          matching_versions = search(current)
-
-          # If we found no versions that match the current requirement
-          if matching_versions.empty?
-            # If this is a top-level Gemfile requirement
-            if current.required_by.empty?
-              if base = @base[current.name] and !base.empty?
-                version = base.first.version
-                message = "You have requested:\n" \
-                  "  #{current.name} #{current.requirement}\n\n" \
-                  "The bundle currently has #{current.name} locked at #{version}.\n" \
-                  "Try running `bundle update #{current.name}`"
-              elsif current.source
-                name = current.name
-                versions = @source_requirements[name][name].map { |s| s.version }
-                message  = "Could not find gem '#{current}' in #{current.source}.\n"
-                if versions.any?
-                  message << "Source contains '#{name}' at: #{versions.join(', ')}"
-                else
-                  message << "Source does not contain any versions of '#{current}'"
-                end
-              else
-                message = "Could not find gem '#{current}' "
-                if @index.source_types.include?(Bundler::Source::Rubygems)
-                  message << "in any of the gem sources listed in your Gemfile."
-                else
-                  message << "in the gems available on this machine."
-                end
-              end
-              raise GemNotFound, message
-              # This is not a top-level Gemfile requirement
-            else
-              @errors[current.name] = [nil, current]
-              parent = handle_conflict(current, states)
-              reqs, activated, depth = resolve_conflict(parent, states)
-              next
-            end
-          end
-
-
-          state = State.new(reqs.dup, activated.dup, current, matching_versions, depth, conflicts)
-          states << state
-          requirement = state.possibles.pop
-          activate_gem(reqs, activated, requirement, current)
+    def search_for(dependency)
+      platform = dependency.__platform
+      dependency = dependency.dep unless dependency.is_a? Gem::Dependency
+      search = @search_for[dependency] ||= begin
+        index = @source_requirements[dependency.name] || @index
+        results = index.search(dependency, @base[dependency.name])
+        if vertex = @base_dg.vertex_named(dependency.name)
+          locked_requirement = vertex.payload.requirement
         end
-      end
-      successify(activated)
-    end
-
-    def gems_size(dep)
-      search(dep).size
-    end
-
-    def clear_search_cache
-      @deps_for = {}
-    end
-
-    def search(dep)
-      if base = @base[dep.name] and base.any?
-        reqs = [dep.requirement.as_list, base.first.version.to_s].flatten.compact
-        d = Gem::Dependency.new(base.first.name, *reqs)
-      else
-        d = dep.dep
-      end
-
-      @deps_for[d.hash] ||= begin
-        index = @source_requirements[d.name] || @index
-        results = index.search(d, @base[d.name])
-
         if results.any?
           version = results.first.version
           nested  = [[]]
@@ -416,139 +266,74 @@ module Bundler
             end
             nested.last << spec
           end
-          deps = nested.map{|a| SpecGroup.new(a) }.select{|sg| sg.for?(dep.__platform) }
+          groups = nested.map { |a| SpecGroup.new(a) }
+          !locked_requirement ? groups : groups.select { |sg| locked_requirement.satisfied_by? sg.version }
         else
-          deps = []
+          []
         end
       end
+      search.select { |sg| sg.for?(platform) }.each { |sg| sg.activate_platform(platform) }
     end
 
-    def clean_req(req)
-      if req.to_s.include?(">= 0")
-        req.to_s.gsub(/ \(.*?\)$/, '')
-      else
-        req.to_s.gsub(/\, (runtime|development)\)$/, ')')
-      end
+    def name_for(dependency)
+      dependency.name
     end
 
-    def version_conflict(current_traversal=true)
-      raise VersionConflict.new(errors.keys, error_message) if current_traversal
-      reset_state
-      start(initial_reqs, true)
+    def name_for_explicit_dependency_source
+      'Gemfile'
     end
 
-    def reset_state
-      clear_search_cache
-      @errors = {}
+    def name_for_locking_dependency_source
+      'Gemfile.lock'
     end
 
-    # For a given conflicted requirement, print out what exactly went wrong
-    def gem_message(requirement, required_by=[])
-      m = ""
-
-      # A requirement that is required by itself is actually in the Gemfile, and does
-      # not "depend on" itself
-      if requirement.required_by.first && requirement.required_by.first.name != requirement.name
-        dependency_tree(m, required_by)
-        m << "#{clean_req(requirement)}\n"
-      else
-        m << "    #{clean_req(requirement)}\n"
-      end
-      m << "\n"
+    def requirement_satisfied_by?(requirement, activated, spec)
+      requirement.matches_spec?(spec)
     end
 
-    def dependency_tree(m, requirements)
-      requirements.each_with_index do |i, j|
-        m << "    " << ("  " * j)
-        m << "#{clean_req(i)}"
-        m << " depends on\n"
+    def sort_dependencies(dependencies, activated, conflicts)
+      dependencies.sort_by do |dependency|
+        name = name_for(dependency)
+        [
+          activated.vertex_named(name).payload ? 0 : 1,
+          @prereleases_cache[dependency.requirement] ? 0 : 1,
+          conflicts[name] ? 0 : 1,
+          activated.vertex_named(name).payload ? 0 : search_for(dependency).count,
+        ]
       end
-      m << "    " << ("  " * requirements.size)
     end
 
-    def error_message
-      errors.inject("") do |o, (conflict, (origin, requirement))|
-
-        # origin is the SpecSet of specs from the Gemfile that is conflicted with
-        if origin
-
-          o << %{Bundler could not find compatible versions for gem "#{origin.name}":\n}
-          o << "  In Gemfile:\n"
-
-          required_by = requirement.required_by
-          o << gem_message(requirement, required_by)
-
-          # If the origin is "bundler", the conflict is us
-          if origin.name == "bundler"
-            o << "  Current Bundler version:\n"
-            other_bundler_required = !requirement.requirement.satisfied_by?(origin.version)
-          # If the origin is a LockfileParser, it does not respond_to :required_by
-          elsif !origin.respond_to?(:required_by) || !(origin.required_by.first)
-            o << "  In snapshot (Gemfile.lock):\n"
-          end
-
-          required_by = origin.required_by[0..-2]
-          o << gem_message(origin, required_by)
-
-          # If the bundle wants a newer bundler than the running bundler, explain
-          if origin.name == "bundler" && other_bundler_required
-            o << "This Gemfile requires a different version of Bundler.\n"
-            o << "Perhaps you need to update Bundler by running `gem install bundler`?"
-          end
-
-        # origin is nil if the required gem and version cannot be found in any of
-        # the specified sources
-        else
-
-          # if the gem cannot be found because of a version conflict between lockfile and gemfile,
-          # print a useful error that suggests running `bundle update`, which may fix things
-          #
-          # @base is a SpecSet of the gems in the lockfile
-          # conflict is the name of the gem that could not be found
-          if locked = @base[conflict].first
-            o << "Bundler could not find compatible versions for gem #{conflict.inspect}:\n"
-            o << "  In snapshot (Gemfile.lock):\n"
-            o << "    #{clean_req(locked)}\n\n"
-
-            o << "  In Gemfile:\n"
-
-            required_by = requirement.required_by
-            o << gem_message(requirement, required_by)
-            o << "Running `bundle update` will rebuild your snapshot from scratch, using only\n"
-            o << "the gems in your Gemfile, which may resolve the conflict.\n"
-
-          # the rest of the time, the gem cannot be found because it does not exist in the known sources
+    def verify_gemfile_dependencies_are_found!(requirements)
+      requirements.each do |requirement|
+        next if requirement.name == 'bundler'
+        if search_for(requirement).empty?
+          if base = @base[requirement.name] and !base.empty?
+            version = base.first.version
+            message = "You have requested:\n" \
+              "  #{requirement.name} #{requirement.requirement}\n\n" \
+              "The bundle currently has #{requirement.name} locked at #{version}.\n" \
+              "Try running `bundle update #{requirement.name}`"
+          elsif requirement.source
+            name = requirement.name
+            versions = @source_requirements[name][name].map { |s| s.version }
+            message  = "Could not find gem '#{requirement}' in #{requirement.source}.\n"
+            if versions.any?
+              message << "Source contains '#{name}' at: #{versions.join(', ')}"
+            else
+              message << "Source does not contain any versions of '#{requirement}'"
+            end
           else
-            if requirement.required_by.first
-              o << "Could not find gem '#{clean_req(requirement)}', which is required by "
-              o << "gem '#{clean_req(requirement.required_by.first)}', in any of the sources."
+            message = "Could not find gem '#{requirement}' "
+            if @index.source_types.include?(Bundler::Source::Rubygems)
+              message << "in any of the gem sources listed in your Gemfile."
             else
-              o << "Could not find gem '#{clean_req(requirement)} in any of the sources\n"
+              message << "in the gems available on this machine."
             end
           end
-
+          raise GemNotFound, message
         end
-        o
       end
     end
 
-    private
-
-    # Indicates progress by writing a '.' every iteration_rate time which is
-    # approximately every second. iteration_rate is calculated in the first
-    # second of resolve running.
-    def indicate_progress
-      @iteration_counter += 1
-
-      if iteration_rate.nil?
-        if ((Time.now - started_at) % 3600).round >= 1
-          @iteration_rate = iteration_counter
-        end
-      else
-        if ((iteration_counter % iteration_rate) == 0)
-          Bundler.ui.info ".", false
-        end
-      end
-    end
   end
 end