bundler 1.5.3 → 1.6.0.pre.1

data/lib/bundler/friendly_errors.rb

@@ -22,7 +22,7 @@ module Bundler
     Bundler.ui.warn <<-WARN, :wrap => true
       You must recompile Ruby with OpenSSL support or change the sources in your \
       Gemfile from 'https' to 'http'. Instructions for compiling with OpenSSL \
-      using RVM are available at rvm.io/packages/openssl.
+      using RVM are available at http://rvm.io/packages/openssl.
     WARN
     Bundler.ui.trace e
     exit 1

data/lib/bundler/installer.rb

@@ -90,7 +90,7 @@ module Bundler
       # dependencies might actually affect the installation of a gem.
       # that said, it's a rare situation (other than rake), and parallel
       # installation is just SO MUCH FASTER. so we let people opt in.
-      jobs = [Bundler.settings[:jobs].to_i-1, 1].max
+      jobs = [Bundler.settings[:jobs].to_i, 1].max
       if jobs > 1 && can_install_parallely?
         install_in_parallel jobs, options[:standalone]
       else
@@ -109,10 +109,13 @@ module Bundler
       debug_message        = nil
       Bundler.rubygems.with_build_args [settings] do
         install_message, post_install_message, debug_message = spec.source.install(spec)
-        Bundler.ui.info install_message
+        if install_message.include? 'Installing'
+          Bundler.ui.confirm install_message
+        else
+          Bundler.ui.info install_message
+        end
         Bundler.ui.debug debug_message if debug_message
-        spec_info = "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
-        Bundler.ui.debug spec_info
+        Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
       end
 
       if Bundler.settings[:bin] && standalone
@@ -283,19 +286,13 @@ module Bundler
         message = install_gem_from_spec spec, standalone, worker
         { :name => spec.name, :post_install => message }
       }
-      specs.each do |spec|
-        if ready_to_install?(spec, remains)
-          worker_pool.enq spec.name
-          enqueued[spec.name] = true
-        end
-      end
 
-      until remains.empty?
-        message = worker_pool.deq
-        remains.delete message[:name]
-        if message[:post_install]
-          Installer.post_install_messages[message[:name]] = message[:post_install]
-        end
+      # Keys in the remains hash represent uninstalled gems specs.
+      # We enqueue all gem specs that do not have any dependencies.
+      # Later we call this lambda again to install specs that depended on
+      # previously installed specifications. We continue until all specs
+      # are installed.
+      enqueue_remaining_specs = lambda do
         remains.keys.each do |name|
           next if enqueued[name]
           spec = name2spec[name]
@@ -305,14 +302,28 @@ module Bundler
           end
         end
       end
+      enqueue_remaining_specs.call
+
+      until remains.empty?
+        message = worker_pool.deq
+        remains.delete message[:name]
+        if message[:post_install]
+          Installer.post_install_messages[message[:name]] = message[:post_install]
+        end
+        enqueue_remaining_specs.call
+      end
       message
     ensure
       worker_pool && worker_pool.stop
     end
 
+    # We only want to install a gem spec if all its dependencies are met.
+    # If the dependency is no longer in the `remains` hash then it has been met.
+    # If a dependency is only development or is self referential it can be ignored.
     def ready_to_install?(spec, remains)
       spec.dependencies.none? do |dep|
-        remains[dep.name] && dep.type != :development && dep.name != spec.name
+        next if dep.type == :development || dep.name == spec.name
+        remains[dep.name]
       end
     end
   end

data/lib/bundler/parallel_workers/worker.rb

@@ -45,7 +45,7 @@ module Bundler
       end
 
       private
-      # Stop the worker threads by sending a poison object down the request queue 
+      # Stop the worker threads by sending a poison object down the request queue
       # so as worker threads after retrieving it, shut themselves down
       def stop_threads
         @threads.each do

data/lib/bundler/resolver.rb

@@ -1,5 +1,4 @@
 require 'set'
-require 'bundler/safe_catch'
 # 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.
@@ -22,8 +21,6 @@ end
 
 module Bundler
   class Resolver
-    include SafeCatch
-    extend SafeCatch
 
     ALL = Bundler::Dependency::PLATFORM_MAP.values.uniq.freeze
 
@@ -129,11 +126,7 @@ module Bundler
       Bundler.ui.info "Resolving dependencies...", false
       base = SpecSet.new(base) unless base.is_a?(SpecSet)
       resolver = new(index, source_requirements, base)
-      result = safe_catch(:success) do
-        resolver.start(requirements)
-        raise resolver.version_conflict
-        nil
-      end
+      result = resolver.start(requirements)
       Bundler.ui.info "" # new line now that dots are done
       SpecSet.new(result)
     rescue => e
@@ -172,220 +165,198 @@ module Bundler
       resolve(reqs, activated)
     end
 
-    def resolve(reqs, activated, depth = 0)
-      # If the requirements are empty, then we are in a success state. Aka, all
-      # gem dependencies have been resolved.
-      safe_throw :success, successify(activated) if reqs.empty?
-
-      indicate_progress
-
-      debug { print "\e[2J\e[f" ; "==== Iterating ====\n\n" }
-
-      # Sort dependencies so that the ones that are easiest to resolve are first.
-      # Easiest to resolve is defined by:
-      #   1) Is this gem already activated?
-      #   2) Do the version requirements include prereleased gems?
-      #   3) Sort by number of gems available in the source.
-      reqs = reqs.sort_by do |a|
-        [ activated[a.name] ? 0 : 1,
-          a.requirement.prerelease? ? 0 : 1,
-          @errors[a.name]   ? 0 : 1,
-          activated[a.name] ? 0 : @gems_size[a] ]
+    class State < Struct.new(:reqs, :activated, :requirement, :possibles, :depth)
+      def name
+        requirement.name
       end
+    end
 
-      debug { "Activated:\n" + activated.values.map {|a| "  #{a}" }.join("\n") }
-      debug { "Requirements:\n" + reqs.map {|r| "  #{r}"}.join("\n") }
+    def handle_conflict(current, states)
+      return unless current
+      parent = current
+      state = states.detect { |i| i.name == parent.name }
+      until (state && state.possibles.any?) || parent.required_by.empty?
+        parent = parent.required_by.last
+        state = states.detect { |i| i.name == parent.name }
+      end
+      return parent, state
+    end
 
-      activated = activated.dup
+    def other_possible?(conflict, states)
+      return unless conflict
+      state = states.detect { |i| i.name == conflict.name }
+      state && state.possibles.any?
+    end
 
-      # Pull off the first requirement so that we can resolve it
-      current = reqs.shift
+    def find_conflict_state(conflict, states)
+      until states.empty? do
+        state = states.pop
+        return state if conflict.name == state.name
+      end
+    end
 
-      $stderr.puts "#{' ' * depth}#{current}" if ENV['DEBUG_RESOLVER_TREE']
+    def activate_gem(reqs, activated, requirement, current)
+      requirement.required_by.replace current.required_by
+      requirement.required_by << current
+      activated[requirement.name] = requirement
 
-      debug { "Attempting:\n  #{current}"}
+      debug { "  Activating: #{requirement.name} (#{requirement.version})" }
+      debug { requirement.required_by.map { |d| "    * #{d.name} (#{d.requirement})" }.join("\n") }
 
-      # Check if the gem has already been activated, if it has, we will make sure
-      # that the currently activated gem satisfies the requirement.
-      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
+      dependencies = requirement.activate_platform(current.__platform)
 
-        if current.requirement.satisfied_by?(existing.version)
-          debug { "    * [SUCCESS] Already activated" }
-          @errors.delete(existing.name)
-          # Since the current requirement is satisfied, we can continue resolving
-          # the remaining requirements.
-
-          # I have no idea if this is the right way to do it, but let's see if it works
-          # The current requirement might activate some other platforms, so let's try
-          # adding those requirements here.
-          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
+      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
 
-          resolve(reqs, activated, depth + 1)
-        else
-          debug { "    * [FAIL] Already activated" }
-          @errors[existing.name] = [existing, current]
-          debug { current.required_by.map {|d| "      * #{d.name} (#{d.requirement})" }.join("\n") }
-          # debug { "    * All current conflicts:\n" + @errors.keys.map { |c| "      - #{c}" }.join("\n") }
-          # Since the current requirement conflicts with an activated gem, we need
-          # to backtrack to the current requirement's parent and try another version
-          # of it (maybe the current requirement won't be present anymore). If the
-          # current requirement is a root level requirement, we need to jump back to
-          # where the conflicting gem was activated.
-          parent = current.required_by.last
-          # `existing` could not respond to required_by if it is part of the base set
-          # of specs that was passed to the resolver (aka, instance of LazySpecification)
-          parent ||= existing.required_by.last if existing.respond_to?(:required_by)
-          # We track the spot where the current gem was activated because we need
-          # to keep a list of every spot a failure happened.
-          if parent && parent.name != 'bundler'
-            debug { "    -> Jumping to: #{parent.name}" }
-            required_by = existing.respond_to?(:required_by) && existing.required_by.last
-            safe_throw parent.name, required_by && required_by.name
-          else
-            # The original set of dependencies conflict with the base set of specs
-            # passed to the resolver. This is by definition an impossible resolve.
-            raise version_conflict
-          end
-        end
-      else
-        # There are no activated gems for the current requirement, so we are going
-        # to find all gems that match the current requirement and try them in decending
-        # order. We also need to keep a set of all conflicts that happen while trying
-        # this gem. This is so that if no versions work, we can figure out the best
-        # place to backtrack to.
-        conflicts = Set.new
-
-        # Fetch all gem versions matching the requirement
-        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]
-          end
-        end
+    def resolve_for_conflict(state)
+      raise version_conflict if state.nil? || state.possibles.empty?
+      reqs, activated, depth = state.reqs.dup, state.activated.dup, state.depth
+      requirement = state.requirement
+      possible = state.possibles.pop
 
-        matching_versions.reverse_each do |spec_group|
-          conflict = resolve_requirement(spec_group, current, reqs.dup, activated.dup, depth)
-          conflicts << conflict if conflict
-        end
+      activate_gem(reqs, activated, possible, requirement)
 
-        # We throw the conflict up the dependency chain if it has not been
-        # resolved (in @errors), thus avoiding branches of the tree that have no effect
-        # on this conflict.  Note that if the tree has multiple conflicts, we don't
-        # care which one we throw, as long as we get out safe
-        if !current.required_by.empty? && !conflicts.empty?
-          @errors.reverse_each do |req_name, pair|
-            if conflicts.include?(req_name)
-              # Choose the closest pivot in the stack that will affect the conflict
-              errorpivot = (@stack & [req_name, current.required_by.last.name]).last
-              debug { "    -> Jumping to: #{errorpivot}" }
-              safe_throw errorpivot, req_name
-            end
-          end
+      return reqs, activated, depth
+    end
+
+    def resolve_conflict(current, states)
+      # Return a requirment/gem which has other possibles states
+      # Given the set of constraints placed by requrired_by
+      parent, _ = handle_conflict(current, states)
+
+      debug { "    -> Going to: #{parent.name} state" }
+
+      # Find the state where the conlict has occured
+      state = find_conflict_state(parent, states)
+
+      # Resolve the conflicts by rewinding the state
+      # when the conflicted gem was activated
+      reqs, activated, depth = resolve_for_conflict(state)
+
+      # Keep the state around if it still has other possiblities
+      states << state unless state.possibles.empty?
+      clear_search_cache
+
+      return reqs, activated, depth
+    end
+
+    def resolve(reqs, activated)
+      states = []
+      depth = 0
+
+      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,
+            a.requirement.prerelease? ? 0 : 1,
+            @errors[a.name]   ? 0 : 1,
+            activated[a.name] ? 0 : @gems_size[a] ]
         end
 
-        # If the current requirement is a root level gem and we have conflicts, we
-        # can figure out the best spot to backtrack to.
-        if current.required_by.empty? && !conflicts.empty?
-          # Check the current "catch" stack for the first one that is included in the
-          # conflicts set. That is where the parent of the conflicting gem was required.
-          # By jumping back to this spot, we can try other version of the parent of
-          # the conflicting gem, hopefully finding a combination that activates correctly.
-          @stack.reverse_each do |savepoint|
-            if conflicts.include?(savepoint)
-              debug { "    -> Jumping to: #{savepoint}" }
-              safe_throw savepoint
-            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
-        end
-      end
-    end
 
-    def resolve_requirement(spec_group, requirement, reqs, activated, depth)
-      # We are going to try activating the spec. We need to keep track of stack of
-      # requirements that got us to the point of activating this gem.
-      spec_group.required_by.replace requirement.required_by
-      spec_group.required_by << requirement
+          if current.requirement.satisfied_by?(existing.version)
+            debug { "    * [SUCCESS] Already activated" }
+            @errors.delete(existing.name)
+            dependencies = existing.activate_platform(current.__platform)
+            reqs.concat dependencies
 
-      activated[spec_group.name] = spec_group
-      debug { "  Activating: #{spec_group.name} (#{spec_group.version})" }
-      debug { spec_group.required_by.map { |d| "    * #{d.name} (#{d.requirement})" }.join("\n") }
+            dependencies.each do |dep|
+              next if dep.type == :development
+              @gems_size[dep] ||= gems_size(dep)
+            end
 
-      dependencies = spec_group.activate_platform(requirement.__platform)
+            depth += 1
+            next
+          else
+            debug { "    * [FAIL] Already activated" }
+            @errors[existing.name] = [existing, current]
 
-      # Now, we have to loop through all child dependencies and add them to our
-      # array of requirements.
-      debug { "    Dependencies"}
-      dependencies.each do |dep|
-        next if dep.type == :development
-        debug { "    * #{dep.name} (#{dep.requirement})" }
-        dep.required_by.replace(requirement.required_by)
-        dep.required_by << requirement
-        @gems_size[dep] ||= gems_size(dep)
-        reqs << dep
-      end
+            parent = current.required_by.last
+            parent, state = handle_conflict(existing.required_by[-2], states) if !other_possible?(parent, states) && existing.respond_to?(:required_by)
+            parent = current unless state && state.possibles.any?
 
-      # We create a savepoint and mark it by the name of the requirement that caused
-      # the gem to be activated. If the activated gem ever conflicts, we are able to
-      # jump back to this point and try another version of the gem.
-      length = @stack.length
-      @stack << requirement.name
-      retval = safe_catch(requirement.name) do
-        # try to resolve the next option
-        resolve(reqs, activated, depth)
-      end
+            raise version_conflict if parent.nil? || parent.name == 'bundler'
 
-      # clear the search cache since the catch means we couldn't meet the
-      # requirement we need with the current constraints on search
-      clear_search_cache
 
-      # Since we're doing a lot of throw / catches. A push does not necessarily match
-      # up to a pop. So, we simply slice the stack back to what it was before the catch
-      # block.
-      @stack.slice!(length..-1)
-      retval
+            reqs, activated, depth = 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]
+              reqs, activated, depth = resolve_conflict(current, states)
+              next
+            end
+          end
+
+          state = State.new(reqs.dup, activated.dup, current, matching_versions, depth)
+          states << state
+          requirement = state.possibles.pop
+          activate_gem(reqs, activated, requirement, current)
+        end
+      end
+      successify(activated)
     end
 
     def gems_size(dep)
@@ -438,20 +409,29 @@ module Bundler
     end
 
     # For a given conflicted requirement, print out what exactly went wrong
-    def gem_message(requirement)
+    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
-        m << "    #{clean_req(requirement.required_by.first)} depends on\n"
-        m << "      #{clean_req(requirement)}\n"
+        dependency_tree(m, required_by)
+        m << "#{clean_req(requirement)}\n"
       else
         m << "    #{clean_req(requirement)}\n"
       end
       m << "\n"
     end
 
+    def dependency_tree(m, requirements)
+      requirements.each_with_index do |i, j|
+        m << "    " << ("  " * j)
+        m << "#{clean_req(i)}"
+        m << " depends on\n"
+      end
+      m << "    " << ("  " * requirements.size)
+    end
+
     def error_message
       errors.inject("") do |o, (conflict, (origin, requirement))|
 
@@ -461,7 +441,8 @@ module Bundler
           o << %{Bundler could not find compatible versions for gem "#{origin.name}":\n}
           o << "  In Gemfile:\n"
 
-          o << gem_message(requirement)
+          required_by = requirement.required_by
+          o << gem_message(requirement, required_by)
 
           # If the origin is "bundler", the conflict is us
           if origin.name == "bundler"
@@ -472,7 +453,8 @@ module Bundler
             o << "  In snapshot (Gemfile.lock):\n"
           end
 
-          o << gem_message(origin)
+          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
@@ -495,7 +477,9 @@ module Bundler
             o << "    #{clean_req(locked)}\n\n"
 
             o << "  In Gemfile:\n"
-            o << gem_message(requirement)
+
+            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"