bundler 1.10.6 → 1.11.0.pre.1

data/lib/bundler/installer/standalone.rb

@@ -0,0 +1,48 @@
+module Bundler
+  class Standalone
+    def initialize(groups, definition)
+      @specs = groups.empty? ? definition.requested_specs : definition.specs_for(groups.map(&:to_sym))
+    end
+
+    def generate
+      SharedHelpers.filesystem_access(bundler_path) do |p|
+        FileUtils.mkdir_p(p)
+      end
+      File.open File.join(bundler_path, "setup.rb"), "w" do |file|
+        file.puts "require 'rbconfig'"
+        file.puts "# ruby 1.8.7 doesn't define RUBY_ENGINE"
+        file.puts "ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'"
+        file.puts "ruby_version = RbConfig::CONFIG[\"ruby_version\"]"
+        file.puts "path = File.expand_path('..', __FILE__)"
+        paths.each do |path|
+          file.puts %($:.unshift "\#{path}/#{path}")
+        end
+      end
+    end
+
+  private
+
+    def paths
+      @specs.map do |spec|
+        next if spec.name == "bundler"
+        Array(spec.require_paths).map do |path|
+          gem_path(path, spec).sub(version_dir, '#{ruby_engine}/#{ruby_version}')
+          # This is a static string intentionally. It's interpolated at a later time.
+        end
+      end.flatten
+    end
+
+    def version_dir
+      "#{Bundler.ruby_version.engine}/#{RbConfig::CONFIG["ruby_version"]}"
+    end
+
+    def bundler_path
+      File.join(Bundler.settings[:path], "bundler")
+    end
+
+    def gem_path(path, spec)
+      full_path = Pathname.new(path).absolute? ? path : File.join(spec.full_gem_path, path)
+      Pathname.new(full_path).relative_path_from(Bundler.root.join(bundler_path)).to_s
+    end
+  end
+end

data/lib/bundler/lazy_specification.rb

@@ -19,7 +19,7 @@ module Bundler
     end
 
     def full_name
-      if platform == Gem::Platform::RUBY or platform.nil? then
+      if platform == Gem::Platform::RUBY || platform.nil?
         "#{@name}-#{@version}"
       else
         "#{@name}-#{@version}-#{platform}"
@@ -35,13 +35,13 @@ module Bundler
     end
 
     def to_lock
-      if platform == Gem::Platform::RUBY or platform.nil?
+      if platform == Gem::Platform::RUBY || platform.nil?
         out = "    #{name} (#{version})\n"
       else
         out = "    #{name} (#{version}-#{platform})\n"
       end
 
-      dependencies.sort_by {|d| d.to_s }.uniq.each do |dep|
+      dependencies.sort_by(&:to_s).uniq.each do |dep|
         next if dep.type == :development
         out << "    #{dep.to_lock}\n"
       end
@@ -78,6 +78,5 @@ module Bundler
 
       @specification.send(method, *args, &blk)
     end
-
   end
 end

data/lib/bundler/lockfile_parser.rb

@@ -34,8 +34,8 @@ module Bundler
       @rubygems_aggregate = Source::Rubygems.new
 
       if lockfile.match(/<<<<<<<|=======|>>>>>>>|\|\|\|\|\|\|\|/)
-        raise LockfileError, "Your Gemfile.lock contains merge conflicts.\n" \
-          "Run `git checkout HEAD -- Gemfile.lock` first to get a clean lock."
+        raise LockfileError, "Your #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} contains merge conflicts.\n" \
+          "Run `git checkout HEAD -- #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}` first to get a clean lock."
       end
 
       lockfile.split(/(?:\r?\n)+/).each do |line|
@@ -59,7 +59,7 @@ module Bundler
       warn_for_outdated_bundler_version
     rescue ArgumentError => e
       Bundler.ui.debug(e)
-      raise LockfileError, "Your lockfile is unreadable. Run `rm Gemfile.lock` " \
+      raise LockfileError, "Your lockfile is unreadable. Run `rm #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}` " \
         "and then `bundle install` to generate a new lockfile."
     end
 
@@ -92,7 +92,8 @@ module Bundler
       case line
       when GIT, GEM, PATH
         @current_source = nil
-        @opts, @type = {}, line
+        @opts = {}
+        @type = line
       when SPECS
         case @type
         when PATH
@@ -102,7 +103,7 @@ module Bundler
           @current_source = TYPES[@type].from_lock(@opts)
           # Strip out duplicate GIT sections
           if @sources.include?(@current_source)
-            @current_source = @sources.find { |s| s == @current_source }
+            @current_source = @sources.find {|s| s == @current_source }
           else
             @sources << @current_source
           end
@@ -131,19 +132,21 @@ module Bundler
     end
 
     NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
-    NAME_VERSION_2 = %r{^ {2}#{NAME_VERSION}(!)?$}
-    NAME_VERSION_4 = %r{^ {4}#{NAME_VERSION}$}
-    NAME_VERSION_6 = %r{^ {6}#{NAME_VERSION}$}
+    NAME_VERSION_2 = /^ {2}#{NAME_VERSION}(!)?$/
+    NAME_VERSION_4 = /^ {4}#{NAME_VERSION}$/
+    NAME_VERSION_6 = /^ {6}#{NAME_VERSION}$/
 
     def parse_dependency(line)
       if line =~ NAME_VERSION_2
-        name, version, pinned = $1, $2, $4
-        version = version.split(",").map { |d| d.strip } if version
+        name = $1
+        version = $2
+        pinned = $4
+        version = version.split(",").map(&:strip) if version
 
         dep = Bundler::Dependency.new(name, version)
 
-        if pinned && dep.name != 'bundler'
-          spec = @specs.find {|k, v| v.name == dep.name }
+        if pinned && dep.name != "bundler"
+          spec = @specs.find {|_, v| v.name == dep.name }
           dep.source = spec.last.source if spec
 
           # Path sources need to know what the default name / version
@@ -162,7 +165,8 @@ module Bundler
 
     def parse_spec(line)
       if line =~ NAME_VERSION_4
-        name, version = $1, Gem::Version.new($2)
+        name = $1
+        version = Gem::Version.new($2)
         platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
         @current_spec = LazySpecification.new(name, version, platform)
         @current_spec.source = @current_source
@@ -171,17 +175,16 @@ module Bundler
         # duplicate GIT sections)
         @specs[@current_spec.identifier] ||= @current_spec
       elsif line =~ NAME_VERSION_6
-        name, version = $1, $2
-        version = version.split(',').map { |d| d.strip } if version
+        name = $1
+        version = $2
+        version = version.split(",").map(&:strip) if version
         dep = Gem::Dependency.new(name, version)
         @current_spec.dependencies << dep
       end
     end
 
     def parse_platform(line)
-      if line =~ /^  (.*)$/
-        @platforms << Gem::Platform.new($1)
-      end
+      @platforms << Gem::Platform.new($1) if line =~ /^  (.*)$/
     end
 
     def parse_bundled_with(line)
@@ -190,6 +193,5 @@ module Bundler
         @bundler_version = Gem::Version.create(line)
       end
     end
-
   end
 end

data/lib/bundler/match_platform.rb

@@ -1,13 +1,13 @@
-require 'bundler/gem_helpers'
+require "bundler/gem_helpers"
 
 module Bundler
   module MatchPlatform
     include GemHelpers
 
     def match_platform(p)
-      Gem::Platform::RUBY == platform or
-      platform.nil? or p == platform or
-      generic(Gem::Platform.new(platform)) === p
+      Gem::Platform::RUBY == platform ||
+        platform.nil? || p == platform ||
+        generic(Gem::Platform.new(platform)) === p
     end
   end
 end

data/lib/bundler/psyched_yaml.rb

@@ -1,19 +1,19 @@
 # Psych could be a gem, so try to ask for it
 begin
-  gem 'psych'
+  gem "psych"
 rescue LoadError
 end if defined?(gem)
 
 # Psych could just be in the stdlib
 # but it's too late if Syck is already loaded
 begin
-  require 'psych' unless defined?(Syck)
+  require "psych" unless defined?(Syck)
 rescue LoadError
   # Apparently Psych wasn't available. Oh well.
 end
 
 # At least load the YAML stdlib, whatever that may be
-require 'yaml' unless defined?(YAML.dump)
+require "yaml" unless defined?(YAML.dump)
 
 module Bundler
   # On encountering invalid YAML,

data/lib/bundler/remote_specification.rb

@@ -27,7 +27,7 @@ module Bundler
     end
 
     def full_name
-      if platform == Gem::Platform::RUBY or platform.nil? then
+      if platform == Gem::Platform::RUBY || platform.nil?
         "#{@name}-#{@version}"
       else
         "#{@name}-#{@version}-#{platform}"

data/lib/bundler/resolver.rb

@@ -1,52 +1,48 @@
-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.
-
 module Bundler
   class Resolver
-
-    require 'bundler/vendored_molinillo'
+    require "bundler/vendored_molinillo"
 
     class Molinillo::VersionConflict
-      def clean_req(req)
-        if req.to_s.include?(">= 0")
-          req.to_s.gsub(/ \(.*?\)$/, '')
+      def printable_dep(dep)
+        if dep.is_a?(Bundler::Dependency)
+          DepProxy.new(dep, dep.platforms.join(", ")).to_s.strip
         else
-          req.to_s.gsub(/\, (runtime|development)\)$/, ')')
+          dep.to_s
         end
       end
 
       def message
-        conflicts.values.flatten.reduce('') do |o, conflict|
-          o << %(Bundler could not find compatible versions for gem "#{conflict.requirement.name}":\n)
+        conflicts.sort.reduce("") do |o, (name, conflict)|
+          o << %(Bundler could not find compatible versions for gem "#{name}":\n)
           if conflict.locked_requirement
-            o << %(  In snapshot (Gemfile.lock):\n)
-            o << %(    #{clean_req conflict.locked_requirement}\n)
+            o << %(  In snapshot (#{Bundler.default_lockfile.basename}):\n)
+            o << %(    #{printable_dep(conflict.locked_requirement)}\n)
             o << %(\n)
           end
           o << %(  In Gemfile:\n)
-          o << conflict.requirement_trees.map do |tree|
-            t = ''
+          o << conflict.requirement_trees.sort_by {|t| t.reverse.map(&:name) }.map do |tree|
+            t = ""
             depth = 2
             tree.each do |req|
-              t << '  ' * depth << %(#{clean_req req})
-              t << %( depends on) unless tree[-1] == req
+              t << "  " * depth << req.to_s
+              unless tree.last == req
+                if spec = conflict.activated_by_name[req.name]
+                  t << %( was resolved to #{spec.version}, which)
+                end
+                t << %( depends on)
+              end
               t << %(\n)
               depth += 1
             end
             t
           end.join("\n")
 
-          if conflict.requirement.name == 'bundler'
+          if 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
+          if 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"
@@ -56,11 +52,12 @@ module Bundler
             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
+            o << "\n"
             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."
+              o << "Could not find gem '#{conflict.requirement}', which is required by "
+              o << "gem '#{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"
+              o << "Could not find gem '#{conflict.requirement}' in any of the sources\n"
             end
           end
           o
@@ -83,7 +80,7 @@ module Bundler
         @specs        = {}
 
         ALL.each do |p|
-          @specs[p] = reverse.find { |s| s.match_platform(p) }
+          @specs[p] = reverse.find {|s| s.match_platform(p) }
         end
       end
 
@@ -97,21 +94,20 @@ module Bundler
         specs = {}
 
         @activated.each do |p|
-          if s = @specs[p]
-            platform = generic(Gem::Platform.new(s.platform))
-            next if specs[platform]
+          next unless s = @specs[p]
+          platform = generic(Gem::Platform.new(s.platform))
+          next if specs[platform]
 
-            lazy_spec = LazySpecification.new(name, version, platform, source)
-            lazy_spec.dependencies.replace s.dependencies
-            specs[platform] = lazy_spec
-          end
+          lazy_spec = LazySpecification.new(name, version, platform, source)
+          lazy_spec.dependencies.replace s.dependencies
+          specs[platform] = lazy_spec
         end
         specs.values
       end
 
       def activate_platform(platform)
         unless @activated.include?(platform)
-          if for?(platform)
+          if for?(platform, nil)
             @activated << platform
             return __dependencies[platform] || []
           end
@@ -131,8 +127,14 @@ module Bundler
         @source ||= first.source
       end
 
-      def for?(platform)
-        @specs[platform]
+      def for?(platform, required_ruby_version)
+        if spec = @specs[platform]
+          if required_ruby_version && spec_required_ruby_version = spec.required_ruby_version
+            spec_required_ruby_version.satisfied_by?(required_ruby_version)
+          else
+            true
+          end
+        end
       end
 
       def to_s
@@ -140,11 +142,11 @@ module Bundler
       end
 
       def dependencies_for_activated_platforms
-        @activated.map { |p| __dependencies[p] }.flatten
+        @activated.map {|p| __dependencies[p] }.flatten
       end
 
       def platforms_for_dependency_named(dependency)
-        __dependencies.select { |p, deps| deps.map(&:name).include? dependency }.keys
+        __dependencies.select {|_, deps| deps.map(&:name).include? dependency }.keys
       end
 
     private
@@ -153,12 +155,11 @@ module Bundler
         @dependencies ||= begin
           dependencies = {}
           ALL.each do |p|
-            if spec = @specs[p]
-              dependencies[p] = []
-              spec.dependencies.each do |dep|
-                next if dep.type == :development
-                dependencies[p] << DepProxy.new(dep, p)
-              end
+            next unless spec = @specs[p]
+            dependencies[p] = []
+            spec.dependencies.each do |dep|
+              next if dep.type == :development
+              dependencies[p] << DepProxy.new(dep, p)
             end
           end
           dependencies
@@ -176,22 +177,22 @@ module Bundler
     # ==== Returns
     # <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 = [])
+    def self.resolve(requirements, index, source_requirements = {}, base = [], ruby_version = nil)
       base = SpecSet.new(base) unless base.is_a?(SpecSet)
-      resolver = new(index, source_requirements, base)
+      resolver = new(index, source_requirements, base, ruby_version)
       result = resolver.start(requirements)
       SpecSet.new(result)
     end
 
-
-    def initialize(index, source_requirements, base)
+    def initialize(index, source_requirements, base, ruby_version)
       @index = index
       @source_requirements = source_requirements
       @base = base
       @resolver = Molinillo::Resolver.new(self, self)
       @search_for = {}
       @base_dg = Molinillo::DependencyGraph.new
-      @base.each { |ls| @base_dg.add_root_vertex ls.name, Dependency.new(ls.name, ls.version) }
+      @base.each {|ls| @base_dg.add_vertex(ls.name, Dependency.new(ls.name, ls.version), true) }
+      @ruby_version = ruby_version ? Gem::Version.create(ruby_version) : nil
     end
 
     def start(requirements)
@@ -201,10 +202,10 @@ module Bundler
     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" \
+      names = e.dependencies.sort_by(&:name).map {|d| "gem '#{d.name}'" }
+      raise CyclicDependencyError, "Your bundle requires gems that depend" \
         " on each other, creating an infinite loop. Please remove" \
-        " #{names.count > 1 ? 'either ' : '' }#{names.join(' or ')}" \
+        " #{names.count > 1 ? "either " : ""}#{names.join(" or ")}" \
         " and try again."
     end
 
@@ -218,27 +219,27 @@ module Bundler
       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 }
+        STDERR.puts debug_info.split("\n").map {|s| "  " * depth + s }
       end
     end
 
     def debug?
-      ENV['DEBUG_RESOLVER'] || ENV['DEBUG_RESOLVER_TREE']
+      ENV["DEBUG_RESOLVER"] || ENV["DEBUG_RESOLVER_TREE"]
     end
 
     def before_resolution
-      Bundler.ui.info 'Resolving dependencies...', false
+      Bundler.ui.info "Resolving dependencies...", false
     end
 
     def after_resolution
-      Bundler.ui.info ''
+      Bundler.ui.info ""
     end
 
     def indicate_progress
-      Bundler.ui.info '.', false
+      Bundler.ui.info ".", false
     end
 
-    private
+  private
 
     include Molinillo::SpecificationProvider
 
@@ -265,13 +266,13 @@ module Bundler
             end
             nested.last << spec
           end
-          groups = nested.map { |a| SpecGroup.new(a) }
-          !locked_requirement ? groups : groups.select { |sg| locked_requirement.satisfied_by? sg.version }
+          groups = nested.map {|a| SpecGroup.new(a) }
+          !locked_requirement ? groups : groups.select {|sg| locked_requirement.satisfied_by? sg.version }
         else
           []
         end
       end
-      search.select { |sg| sg.for?(platform) }.each { |sg| sg.activate_platform(platform) }
+      search.select {|sg| sg.for?(platform, @ruby_version) }.each {|sg| sg.activate_platform(platform) }
     end
 
     def name_for(dependency)
@@ -279,11 +280,15 @@ module Bundler
     end
 
     def name_for_explicit_dependency_source
-      'Gemfile'
+      Bundler.default_gemfile.basename.to_s
+    rescue
+      "Gemfile"
     end
 
     def name_for_locking_dependency_source
-      'Gemfile.lock'
+      Bundler.default_lockfile.basename.to_s
+    rescue
+      "Gemfile.lock"
     end
 
     def requirement_satisfied_by?(requirement, activated, spec)
@@ -305,10 +310,10 @@ module Bundler
     def amount_constrained(dependency)
       @amount_constrained ||= {}
       @amount_constrained[dependency.name] ||= begin
-        if base = @base[dependency.name] and !base.empty?
+        if (base = @base[dependency.name]) && !base.empty?
           dependency.requirement.satisfied_by?(base.first.version) ? 0 : 1
         else
-          base_dep = Dependency.new dependency.name, '>= 0.a'
+          base_dep = Dependency.new dependency.name, ">= 0.a"
           all = search_for(DepProxy.new base_dep, dependency.__platform).size.to_f
           if all.zero?
             0
@@ -323,31 +328,31 @@ module Bundler
 
     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
+        next if requirement.name == "bundler"
+        next unless search_for(requirement).empty?
+        if (base = @base[requirement.name]) && !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}`\n\n" \
+            "If you are updating multiple gems in your Gemfile at once,\n" \
+            "try passing them all to `bundle update`"
+        elsif requirement.source
+          name = requirement.name
+          versions = @source_requirements[name][name].map(&:version)
+          message  = "Could not find gem '#{requirement}' in #{requirement.source}.\n"
+          if versions.any?
+            message << "Source contains '#{name}' at: #{versions.join(", ")}"
           else
-            message = "Could not find gem '#{requirement}' in any of the gem sources " \
-              "listed in your Gemfile or available on this machine."
+            message << "Source does not contain any versions of '#{requirement}'"
           end
-          raise GemNotFound, message
+        else
+          message = "Could not find gem '#{requirement}' in any of the gem sources " \
+            "listed in your Gemfile or available on this machine."
         end
+        raise GemNotFound, message
       end
     end
-
   end
 end