bundler 1.14.6 → 1.15.0.pre.1

data/lib/bundler/resolver.rb

@@ -14,14 +14,23 @@ module Bundler
 
       def message
         conflicts.sort.reduce(String.new) do |o, (name, conflict)|
-          o << %(Bundler could not find compatible versions for gem "#{name}":\n)
+          o << %(\nBundler could not find compatible versions for gem "#{name}":\n)
           if conflict.locked_requirement
             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.sort_by {|t| t.reverse.map(&:name) }.map do |tree|
+          trees = conflict.requirement_trees
+
+          maximal = 1.upto(trees.size).map do |size|
+            trees.map(&:last).flatten(1).combination(size).to_a
+          end.flatten(1).select do |deps|
+            Bundler::VersionRanges.empty?(*Bundler::VersionRanges.for_many(deps.map(&:requirement)))
+          end.min_by(&:size)
+          trees.reject! {|t| !maximal.include?(t.last) } if maximal
+
+          o << trees.sort_by {|t| t.reverse.map(&:name) }.map do |tree|
             t = String.new
             depth = 2
             tree.each do |req|
@@ -62,7 +71,7 @@ module Bundler
             end
           end
           o
-        end
+        end.strip
       end
     end
 
@@ -318,6 +327,7 @@ module Bundler
       dependencies.sort_by do |dependency|
         name = name_for(dependency)
         [
+          @base_dg.vertex_named(name) ? 0 : 1,
           activated.vertex_named(name).payload ? 0 : 1,
           amount_constrained(dependency),
           conflicts[name] ? 0 : 1,

data/lib/bundler/rubygems_ext.rb

@@ -151,7 +151,7 @@ module Gem
 
     def to_lock
       out = String.new("  #{name}")
-      unless requirement == Gem::Requirement.default
+      unless requirement.none?
         reqs = requirement.requirements.map {|o, v| "#{o} #{v}" }.sort.reverse
         out << " (#{reqs.join(", ")})"
       end
@@ -169,11 +169,16 @@ module Gem
   end
 
   class Requirement
-    # Backport of performance enhancement added to Rubygems 1.4
+    # Backport of performance enhancement added to RubyGems 1.4
     def none?
-      @none ||= (to_s == ">= 0")
+      # note that it might be tempting to replace with with RubyGems 2.0's
+      # improved implementation. Don't. It requires `DefaultRequirement` to be
+      # defined, and more importantantly, these overrides are not used when the
+      # running RubyGems defines these methods
+      to_s == ">= 0"
     end unless allocate.respond_to?(:none?)
 
+    # Backport of performance enhancement added to RubyGems 2.2
     def exact?
       return false unless @requirements.size == 1
       @requirements[0][0] == "="

data/lib/bundler/rubygems_integration.rb

@@ -80,6 +80,10 @@ module Bundler
       default
     end
 
+    def stub_set_spec(stub, spec)
+      stub.instance_variable_set(:@spec, spec)
+    end
+
     def path(obj)
       obj.to_s
     end
@@ -320,48 +324,53 @@ module Bundler
       end
     end
 
-    def replace_gem(specs)
+    def binstubs_call_gem?
+      true
+    end
+
+    def stubs_provide_full_functionality?
+      false
+    end
+
+    def replace_gem(specs, specs_by_name)
       reverse_rubygems_kernel_mixin
 
-      executables = specs.map(&:executables).flatten
+      executables = nil
 
       kernel = (class << ::Kernel; self; end)
       [kernel, ::Kernel].each do |kernel_class|
         redefine_method(kernel_class, :gem) do |dep, *reqs|
-          if executables.include? File.basename(caller.first.split(":").first)
+          executables ||= specs.map(&:executables).flatten if ::Bundler.rubygems.binstubs_call_gem?
+          if executables && executables.include?(File.basename(caller.first.split(":").first))
             break
           end
+
           reqs.pop if reqs.last.is_a?(Hash)
 
           unless dep.respond_to?(:name) && dep.respond_to?(:requirement)
             dep = Gem::Dependency.new(dep, reqs)
           end
 
-          spec = specs.find {|s| s.name == dep.name }
-
-          if spec.nil?
-
-            e = Gem::LoadError.new "#{dep.name} is not part of the bundle. Add it to Gemfile."
-            e.name = dep.name
-            if e.respond_to?(:requirement=)
-              e.requirement = dep.requirement
-            else
-              e.version_requirement = dep.requirement
-            end
-            raise e
-          elsif dep !~ spec
-            e = Gem::LoadError.new "can't activate #{dep}, already activated #{spec.full_name}. " \
-                                   "Make sure all dependencies are added to Gemfile."
-            e.name = dep.name
-            if e.respond_to?(:requirement=)
-              e.requirement = dep.requirement
-            else
-              e.version_requirement = dep.requirement
-            end
-            raise e
+          if spec = specs_by_name[dep.name]
+            return true if dep.matches_spec?(spec)
           end
 
-          true
+          message = if spec.nil?
+            "#{dep.name} is not part of the bundle." \
+            " Add it to your #{Bundler.default_gemfile.basename}."
+          else
+            "can't activate #{dep}, already activated #{spec.full_name}. " \
+            "Make sure all dependencies are added to Gemfile."
+          end
+
+          e = Gem::LoadError.new(message)
+          e.name = dep.name
+          if e.respond_to?(:requirement=)
+            e.requirement = dep.requirement
+          elsif e.respond_to?(:version_requirement=)
+            e.version_requirement = dep.requirement
+          end
+          raise e
         end
 
         # TODO: delete this in 2.0, it's a backwards compatibility shim
@@ -393,20 +402,34 @@ module Bundler
     # Used to make bin stubs that are not created by bundler work
     # under bundler. The new Gem.bin_path only considers gems in
     # +specs+
-    def replace_bin_path(specs)
+    def replace_bin_path(specs, specs_by_name)
       gem_class = (class << Gem; self; end)
 
       redefine_method(gem_class, :find_spec_for_exe) do |gem_name, *args|
         exec_name = args.first
 
+        spec_with_name = specs_by_name[gem_name]
         spec = if exec_name
-          specs.find {|s| s.name == gem_name && s.executables.include?(exec_name) } ||
+          if spec_with_name && spec_with_name.executables.include?(exec_name)
+            spec_with_name
+          else
             specs.find {|s| s.executables.include?(exec_name) }
+          end
         else
-          specs.find {|s| s.name == gem_name }
+          spec_with_name
         end
-        raise(Gem::Exception, "can't find executable #{exec_name}") unless spec
+
+        unless spec
+          message = "can't find executable #{exec_name} for gem #{gem_name}"
+          if !exec_name || spec_with_name.nil?
+            message += ". #{gem_name} is not currently included in the bundle, " \
+                       "perhaps you meant to add it to your #{Bundler.default_gemfile.basename}?"
+          end
+          raise Gem::Exception, message
+        end
+
         raise Gem::Exception, "no default executable for #{spec.full_name}" unless exec_name ||= spec.default_executable
+
         unless spec.name == name
           Bundler::SharedHelpers.major_deprecation \
             "Bundler is using a binstub that was created for a different gem.\n" \
@@ -423,8 +446,10 @@ module Bundler
         # Copy of Rubygems activate_bin_path impl
         requirement = args.last
         spec = find_spec_for_exe name, exec_name, [requirement]
-        Gem::LOADED_SPECS_MUTEX.synchronize { spec.activate }
-        spec.bin_file exec_name
+
+        gem_bin = File.join(spec.full_gem_path, spec.bindir, exec_name)
+        gem_from_path_bin = File.join(File.dirname(spec.loaded_from), spec.bindir, exec_name)
+        File.exist?(gem_bin) ? gem_bin : gem_from_path_bin
       end
 
       redefine_method(gem_class, :bin_path) do |name, *args|
@@ -450,11 +475,14 @@ module Bundler
     # Replace or hook into Rubygems to provide a bundlerized view
     # of the world.
     def replace_entrypoints(specs)
-      replace_gem(specs)
+      specs_by_name = specs.reduce({}) do |h, s|
+        h[s.name] = s
+        h
+      end
 
+      replace_gem(specs, specs_by_name)
       stub_rubygems(specs)
-
-      replace_bin_path(specs)
+      replace_bin_path(specs, specs_by_name)
       replace_refresh
 
       Gem.clear_paths
@@ -746,7 +774,13 @@ module Bundler
       end
 
       def backport_ext_builder_monitor
-        require "rubygems/ext"
+        # So we can avoid requiring "rubygems/ext" in its entirety
+        Gem.module_eval <<-RB, __FILE__, __LINE__ + 1
+          module Ext
+          end
+        RB
+
+        require "rubygems/ext/builder"
 
         Gem::Ext::Builder.class_eval do
           unless const_defined?(:CHDIR_MONITOR)
@@ -777,6 +811,21 @@ module Bundler
         activated_spec_names = runtime.requested_specs.map(&:to_spec).sort_by(&:name)
         [Gemdeps.new(runtime), activated_spec_names]
       end
+
+      if provides?(">= 2.5.2")
+        # RubyGems-generated binstubs call Kernel#gem
+        def binstubs_call_gem?
+          false
+        end
+
+        # only 2.5.2+ has all of the stub methods we want to use, and since this
+        # is a performance optimization _only_,
+        # we'll restrict ourselves to the most
+        # recent RG versions instead of all versions that have stubs
+        def stubs_provide_full_functionality?
+          true
+        end
+      end
     end
   end
 

data/lib/bundler/runtime.rb

@@ -11,6 +11,8 @@ module Bundler
     end
 
     def setup(*groups)
+      @definition.ensure_equivalent_gemfile_and_lockfile if Bundler.settings[:frozen]
+
       groups.map!(&:to_sym)
 
       # Has to happen first
@@ -24,7 +26,7 @@ module Bundler
       # Activate the specs
       load_paths = specs.map do |spec|
         unless spec.loaded_from
-          raise GemNotFound, "#{spec.full_name} is missing. Run `bundle` to get it."
+          raise GemNotFound, "#{spec.full_name} is missing. Run `bundle install` to get it."
         end
 
         if (activated_spec = Bundler.rubygems.loaded_specs(spec.name)) && activated_spec.version != spec.version
@@ -127,6 +129,7 @@ module Bundler
     definition_method :requires
 
     def lock(opts = {})
+      return if @definition.nothing_changed? && !@definition.unlocking?
       @definition.lock(Bundler.default_lockfile, opts[:preserve_unknown_sections])
     end
 

data/lib/bundler/settings.rb

@@ -15,6 +15,8 @@ module Bundler
       disable_exec_load
       disable_local_branch_check
       disable_shared_gems
+      disable_version_check
+      force_ruby_platform
       frozen
       gem.coc
       gem.mit
@@ -22,7 +24,6 @@ module Bundler
       major_deprecations
       no_install
       no_prune
-      force_ruby_platform
       only_update_to_newer_versions
       plugins
       silence_root_warning

data/lib/bundler/setup.rb

@@ -22,7 +22,7 @@ if Bundler::SharedHelpers.in_bundle?
 
   unless ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"]
     # Add bundler to the load path after disabling system gems
-    # This is guarenteed to be done already if we've trampolined
+    # This is guaranteed to be done already if we've trampolined
     bundler_lib = File.expand_path("../..", __FILE__)
     $LOAD_PATH.unshift(bundler_lib) unless $LOAD_PATH.include?(bundler_lib)
   end

data/lib/bundler/shared_helpers.rb

@@ -145,6 +145,31 @@ module Bundler
       major_deprecation("Bundler will only support rubygems >= 2.0, you are running #{Bundler.rubygems.version}")
     end
 
+    def trap(signal, override = false, &block)
+      prior = Signal.trap(signal) do
+        block.call
+        prior.call unless override
+      end
+    end
+
+    def ensure_same_dependencies(spec, old_deps, new_deps)
+      new_deps = new_deps.reject {|d| d.type == :development }
+      old_deps = old_deps.reject {|d| d.type == :development }
+
+      without_type = proc {|d| Gem::Dependency.new(d.name, d.requirements_list.sort) }
+      new_deps.map!(&without_type)
+      old_deps.map!(&without_type)
+
+      extra_deps = new_deps - old_deps
+      return if extra_deps.empty?
+
+      Bundler.ui.debug "#{spec.full_name} from #{spec.remote} has either corrupted API or lockfile dependencies" \
+        " (was expecting #{old_deps.map(&:to_s)}, but the real spec has #{new_deps.map(&:to_s)})"
+      raise APIResponseMismatchError,
+        "Downloading #{spec.full_name} revealed dependencies not in the API or the lockfile (#{extra_deps.join(", ")})." \
+        "\nEither installing with `--full-index` or running `bundle update #{spec.name}` should fix the problem."
+    end
+
   private
 
     def find_gemfile
@@ -246,7 +271,7 @@ module Bundler
     def deprecate_gemfile(gemfile)
       return unless gemfile && File.basename(gemfile) == "Gemfile"
       Bundler::SharedHelpers.major_deprecation \
-        "gems.rb and gems.locked will be prefered to Gemfile and Gemfile.lock."
+        "gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock."
     end
 
     extend self

data/lib/bundler/source.rb

@@ -20,7 +20,7 @@ module Bundler
         locked_spec = Bundler.locked_gems.specs.find {|s| s.name == spec.name }
         locked_spec_version = locked_spec.version if locked_spec
         if locked_spec_version && spec.version != locked_spec_version
-          message += Bundler.ui.add_color(" (was #{locked_spec_version})", :green)
+          message += Bundler.ui.add_color(" (was #{locked_spec_version})", version_color(spec.version, locked_spec_version))
         end
       end
 
@@ -38,5 +38,21 @@ module Bundler
     def inspect
       "#<#{self.class}:0x#{object_id} #{self}>"
     end
+
+  private
+
+    def version_color(spec_version, locked_spec_version)
+      if Gem::Version.correct?(spec_version) && Gem::Version.correct?(locked_spec_version)
+        # display yellow if there appears to be a regression
+        earlier_version?(spec_version, locked_spec_version) ? :yellow : :green
+      else
+        # default to green if the versions cannot be directly compared
+        :green
+      end
+    end
+
+    def earlier_version?(spec_version, locked_spec_version)
+      Gem::Version.new(spec_version) < Gem::Version.new(locked_spec_version)
+    end
   end
 end

data/lib/bundler/source/git.rb

@@ -171,7 +171,10 @@ module Bundler
           git_proxy.copy_to(install_path, submodules)
           serialize_gemspecs_in(install_path)
           @copied = true
+        elsif force
+          git_proxy.copy_to(install_path, submodules)
         end
+
         generate_bin_options = { :disable_extensions => !Bundler.rubygems.spec_missing_extensions?(spec), :build_args => options[:build_args] }
         generate_bin(spec, generate_bin_options)
 
@@ -234,6 +237,8 @@ module Bundler
           # The gemspecs we cache should already be evaluated.
           spec = Bundler.load_gemspec(spec_path)
           next unless spec
+          Bundler.rubygems.set_installed_by_version(spec)
+          Bundler.rubygems.validate(spec)
           File.open(spec_path, "wb") {|file| file.write(spec.to_ruby) }
         end
       end
@@ -298,6 +303,17 @@ module Bundler
         raise unless Bundler.feature_flag.allow_offline_install?
         Bundler.ui.warn "Using cached git data because of network errors"
       end
+
+      # no-op, since we validate when re-serializing the gemspec
+      def validate_spec(_spec); end
+
+      if Bundler.rubygems.stubs_provide_full_functionality?
+        def load_gemspec(file)
+          stub = Gem::StubSpecification.gemspec_stub(file, install_path.parent, install_path.parent)
+          stub.full_gem_path = Pathname.new(file).dirname.expand_path(root).to_s.untaint
+          StubSpecification.from_stub(stub)
+        end
+      end
     end
   end
 end

data/lib/bundler/source/path.rb

@@ -144,18 +144,28 @@ module Bundler
         SharedHelpers.in_bundle? && app_cache_path.exist?
       end
 
+      def load_gemspec(file)
+        return unless spec = Bundler.load_gemspec(file)
+        Bundler.rubygems.set_installed_by_version(spec)
+        spec
+      end
+
+      def validate_spec(spec)
+        Bundler.rubygems.validate(spec)
+      end
+
       def load_spec_files
         index = Index.new
 
         if File.directory?(expanded_path)
           # We sort depth-first since `<<` will override the earlier-found specs
           Dir["#{expanded_path}/#{@glob}"].sort_by {|p| -p.split(File::SEPARATOR).size }.each do |file|
-            next unless spec = Bundler.load_gemspec(file)
+            next unless spec = load_gemspec(file)
             spec.source = self
-            Bundler.rubygems.set_installed_by_version(spec)
+
             # Validation causes extension_dir to be calculated, which depends
             # on #source, so we validate here instead of load_gemspec
-            Bundler.rubygems.validate(spec)
+            validate_spec(spec)
             index << spec
           end