bundler 2.0.2 → 2.1.0.pre.1

data/lib/bundler/plugin/api.rb

@@ -23,7 +23,7 @@ module Bundler
   # and hooks).
   module Plugin
     class API
-      autoload :Source, "bundler/plugin/api/source"
+      autoload :Source, File.expand_path("api/source", __dir__)
 
       # The plugins should declare that they handle a command through this helper.
       #

data/lib/bundler/plugin/api/source.rb

@@ -37,7 +37,7 @@ module Bundler
       #
       # @!attribute [rw] dependency_names
       #   @return [Array<String>] Names of dependencies that the source should
-      #     try to resolve. It is not necessary to use this list intenally. This
+      #     try to resolve. It is not necessary to use this list internally. This
       #     is present to be compatible with `Definition` and is used by
       #     rubygems source.
       module Source
@@ -196,7 +196,7 @@ module Bundler
         # This shall check if two source object represent the same source.
         #
         # The comparison shall take place only on the attribute that can be
-        # inferred from the options passed from Gemfile and not on attibutes
+        # inferred from the options passed from Gemfile and not on attributes
         # that are used to pin down the gem to specific version (e.g. Git
         # sources should compare on branch and tag but not on commit hash)
         #

data/lib/bundler/plugin/index.rb

@@ -103,6 +103,14 @@ module Bundler
         @plugin_paths[name]
       end
 
+      def installed_plugins
+        @plugin_paths.keys
+      end
+
+      def plugin_commands(plugin)
+        @commands.find_all {|_, n| n == plugin }.map(&:first)
+      end
+
       def source?(source)
         @sources.key? source
       end
@@ -131,7 +139,7 @@ module Bundler
 
           data = index_f.read
 
-          require "bundler/yaml_serializer"
+          require_relative "../yaml_serializer"
           index = YAMLSerializer.load(data)
 
           @commands.merge!(index["commands"])
@@ -154,7 +162,7 @@ module Bundler
           "sources"      => @sources,
         }
 
-        require "bundler/yaml_serializer"
+        require_relative "../yaml_serializer"
         SharedHelpers.filesystem_access(index_file) do |index_f|
           FileUtils.mkdir_p(index_f.dirname)
           File.open(index_f, "w") {|f| f.puts YAMLSerializer.dump(index) }

data/lib/bundler/plugin/installer.rb

@@ -8,14 +8,19 @@ module Bundler
   # are heavily dependent on the Gemfile.
   module Plugin
     class Installer
-      autoload :Rubygems, "bundler/plugin/installer/rubygems"
-      autoload :Git,      "bundler/plugin/installer/git"
+      autoload :Rubygems, File.expand_path("installer/rubygems", __dir__)
+      autoload :Git,      File.expand_path("installer/git", __dir__)
 
       def install(names, options)
+        check_sources_consistency!(options)
+
         version = options[:version] || [">= 0"]
-        Bundler.settings.temporary(:lockfile_uses_separate_rubygems_sources => false, :disable_multisource => false) do
+
+        Bundler.settings.temporary(:disable_multisource => false) do
           if options[:git]
             install_git(names, version, options)
+          elsif options[:local_git]
+            install_local_git(names, version, options)
           else
             sources = options[:source] || Bundler.rubygems.sources
             install_rubygems(names, version, sources)
@@ -38,22 +43,24 @@ module Bundler
 
     private
 
+      def check_sources_consistency!(options)
+        if options.key?(:git) && options.key?(:local_git)
+          raise InvalidOption, "Remote and local plugin git sources can't be both specified"
+        end
+      end
+
       def install_git(names, version, options)
         uri = options.delete(:git)
         options["uri"] = uri
 
-        source_list = SourceList.new
-        source_list.add_git_source(options)
-
-        # To support both sources
-        if options[:source]
-          source_list.add_rubygems_source("remotes" => options[:source])
-        end
+        install_all_sources(names, version, options, options[:source])
+      end
 
-        deps = names.map {|name| Dependency.new name, version }
+      def install_local_git(names, version, options)
+        uri = options.delete(:local_git)
+        options["uri"] = uri
 
-        definition = Definition.new(nil, deps, source_list, true)
-        install_definition(definition)
+        install_all_sources(names, version, options, options[:source])
       end
 
       # Installs the plugin from rubygems source and returns the path where the
@@ -65,10 +72,16 @@ module Bundler
       #
       # @return [Hash] map of names to the specs of plugins installed
       def install_rubygems(names, version, sources)
-        deps = names.map {|name| Dependency.new name, version }
+        install_all_sources(names, version, nil, sources)
+      end
 
+      def install_all_sources(names, version, git_source_options, rubygems_source)
         source_list = SourceList.new
-        source_list.add_rubygems_source("remotes" => sources)
+
+        source_list.add_git_source(git_source_options) if git_source_options
+        source_list.add_rubygems_source("remotes" => rubygems_source) if rubygems_source
+
+        deps = names.map {|name| Dependency.new name, version }
 
         definition = Definition.new(nil, deps, source_list, true)
         install_definition(definition)

data/lib/bundler/psyched_yaml.rb

@@ -27,7 +27,7 @@ module Bundler
   end
 end
 
-require "bundler/deprecate"
+require_relative "deprecate"
 begin
   Bundler::Deprecate.skip_during do
     require "rubygems/safe_yaml"

data/lib/bundler/resolver.rb

@@ -2,8 +2,8 @@
 
 module Bundler
   class Resolver
-    require "bundler/vendored_molinillo"
-    require "bundler/resolver/spec_group"
+    require_relative "vendored_molinillo"
+    require_relative "resolver/spec_group"
 
     # Figures out the best possible configuration of gems that satisfies
     # the list of passed dependencies and any child dependencies without
@@ -38,8 +38,8 @@ module Bundler
       @platforms = platforms
       @gem_version_promoter = gem_version_promoter
       @allow_bundler_dependency_conflicts = Bundler.feature_flag.allow_bundler_dependency_conflicts?
-      @lockfile_uses_separate_rubygems_sources = Bundler.feature_flag.lockfile_uses_separate_rubygems_sources?
       @use_gvp = Bundler.feature_flag.use_gem_version_promoter_for_major_updates? || !@gem_version_promoter.major?
+      @lockfile_uses_separate_rubygems_sources = Bundler.feature_flag.disable_multisource?
     end
 
     def start(requirements)
@@ -48,9 +48,12 @@ module Bundler
 
       verify_gemfile_dependencies_are_found!(requirements)
       dg = @resolver.resolve(requirements, @base_dg)
-      dg.map(&:payload).
+      dg.
+        tap {|resolved| validate_resolved_specs!(resolved) }.
+        map(&:payload).
         reject {|sg| sg.name.end_with?("\0") }.
-        map(&:to_specs).flatten
+        map(&:to_specs).
+        flatten
     rescue Molinillo::VersionConflict => e
       message = version_conflict_message(e)
       raise VersionConflict.new(e.conflicts.keys.uniq, message)
@@ -72,7 +75,7 @@ module Bundler
       return unless 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 }
+      warn debug_info.split("\n").map {|s| "  " * depth + s }
     end
 
     def debug?
@@ -169,13 +172,13 @@ module Bundler
 
     def name_for_explicit_dependency_source
       Bundler.default_gemfile.basename.to_s
-    rescue
+    rescue StandardError
       "Gemfile"
     end
 
     def name_for_locking_dependency_source
       Bundler.default_lockfile.basename.to_s
-    rescue
+    rescue StandardError
       "Gemfile.lock"
     end
 
@@ -276,10 +279,10 @@ module Bundler
           versions_with_platforms = specs.map {|s| [s.version, s.platform] }
           message = String.new("Could not find gem '#{SharedHelpers.pretty_dependency(requirement)}' in #{source}#{cache_message}.\n")
           message << if versions_with_platforms.any?
-                       "The source contains '#{name}' at: #{formatted_versions_with_platforms(versions_with_platforms)}"
-                     else
-                       "The source does not contain any versions of '#{name}'"
-                     end
+            "The source contains '#{name}' at: #{formatted_versions_with_platforms(versions_with_platforms)}"
+          else
+            "The source does not contain any versions of '#{name}'"
+          end
         else
           message = "Could not find gem '#{requirement}' in any of the gem sources " \
             "listed in your Gemfile#{cache_message}."
@@ -300,9 +303,19 @@ module Bundler
     end
 
     def version_conflict_message(e)
+      # only show essential conflicts, if possible
+      conflicts = e.conflicts.dup
+      conflicts.delete_if do |_name, conflict|
+        deps = conflict.requirement_trees.map(&:last).flatten(1)
+        !Bundler::VersionRanges.empty?(*Bundler::VersionRanges.for_many(deps.map(&:requirement)))
+      end
+      e = Molinillo::VersionConflict.new(conflicts, e.specification_provider) unless conflicts.empty?
+
+      solver_name = "Bundler"
+      possibility_type = "gem"
       e.message_with_trees(
-        :solver_name => "Bundler",
-        :possibility_type => "gem",
+        :solver_name => solver_name,
+        :possibility_type => possibility_type,
         :reduce_trees => lambda do |trees|
           # called first, because we want to reduce the amount of work required to find maximal empty sets
           trees = trees.uniq {|t| t.flatten.map {|dep| [dep.name, dep.requirement] } }
@@ -314,10 +327,8 @@ module Bundler
           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
 
-          trees = trees.sort_by {|t| t.flatten.map(&:to_s) }
-          trees.uniq! {|t| t.flatten.map {|dep| [dep.name, dep.requirement] } }
+          trees.reject! {|t| !maximal.include?(t.last) } if maximal
 
           trees.sort_by {|t| t.reverse.map(&:name) }
         end,
@@ -325,7 +336,7 @@ module Bundler
         :additional_message_for_conflict => lambda do |o, name, conflict|
           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)
+            other_bundler_required = !conflict.requirement.requirement.satisfied_by?(Gem::Version.new(Bundler::VERSION))
           end
 
           if name == "bundler" && other_bundler_required
@@ -352,7 +363,11 @@ module Bundler
               []
             end.compact.map(&:to_s).uniq.sort
 
-            o << "Could not find gem '#{SharedHelpers.pretty_dependency(conflict.requirement)}'"
+            metadata_requirement = name.end_with?("\0")
+
+            o << "Could not find gem '" unless metadata_requirement
+            o << SharedHelpers.pretty_dependency(conflict.requirement)
+            o << "'" unless metadata_requirement
             if conflict.requirement_trees.first.size > 1
               o << ", which is required by "
               o << "gem '#{SharedHelpers.pretty_dependency(conflict.requirement_trees.first[-2])}',"
@@ -360,14 +375,47 @@ module Bundler
             o << " "
 
             o << if relevant_sources.empty?
-                   "in any of the sources.\n"
-                 else
-                   "in any of the relevant sources:\n  #{relevant_sources * "\n  "}\n"
-                 end
+              "in any of the sources.\n"
+            elsif metadata_requirement
+              "is not available in #{relevant_sources.join(" or ")}"
+            else
+              "in any of the relevant sources:\n  #{relevant_sources * "\n  "}\n"
+            end
           end
         end,
-        :version_for_spec => lambda {|spec| spec.version }
+        :version_for_spec => lambda {|spec| spec.version },
+        :incompatible_version_message_for_conflict => lambda do |name, _conflict|
+          if name.end_with?("\0")
+            %(#{solver_name} found conflicting requirements for the #{name} version:)
+          else
+            %(#{solver_name} could not find compatible versions for #{possibility_type} "#{name}":)
+          end
+        end
       )
     end
+
+    def validate_resolved_specs!(resolved_specs)
+      resolved_specs.each do |v|
+        name = v.name
+        next unless sources = relevant_sources_for_vertex(v)
+        sources.compact!
+        if default_index = sources.index(@source_requirements[:default])
+          sources.delete_at(default_index)
+        end
+        sources.reject! {|s| s.specs[name].empty? }
+        sources.uniq!
+        next if sources.size <= 1
+
+        multisource_disabled = Bundler.feature_flag.disable_multisource?
+
+        msg = ["The gem '#{name}' was found in multiple relevant sources."]
+        msg.concat sources.map {|s| "  * #{s}" }.sort
+        msg << "You #{multisource_disabled ? :must : :should} add this gem to the source block for the source you wish it to be installed from."
+        msg = msg.join("\n")
+
+        raise SecurityError, msg if multisource_disabled
+        Bundler.ui.warn "Warning: #{msg}"
+      end
+    end
   end
 end

data/lib/bundler/resolver/spec_group.rb

@@ -94,10 +94,10 @@ module Bundler
         return [] if !spec.is_a?(EndpointSpecification) && !spec.is_a?(Gem::Specification)
         dependencies = []
         if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?
-          dependencies << DepProxy.new(Gem::Dependency.new("ruby\0", spec.required_ruby_version), platform)
+          dependencies << DepProxy.new(Gem::Dependency.new("Ruby\0", spec.required_ruby_version), platform)
         end
         if !spec.required_rubygems_version.nil? && !spec.required_rubygems_version.none?
-          dependencies << DepProxy.new(Gem::Dependency.new("rubygems\0", spec.required_rubygems_version), platform)
+          dependencies << DepProxy.new(Gem::Dependency.new("RubyGems\0", spec.required_rubygems_version), platform)
         end
         dependencies
       end

data/lib/bundler/retry.rb

@@ -35,10 +35,10 @@ module Bundler
   private
 
     def run(&block)
-      @failed      = false
+      @failed = false
       @current_run += 1
       @result = block.call
-    rescue => e
+    rescue StandardError => e
       fail_attempt(e)
     end
 

data/lib/bundler/ruby_version.rb

@@ -49,7 +49,7 @@ module Bundler
       ([\d.]+) # ruby version
       (?:p(-?\d+))? # optional patchlevel
       (?:\s\((\S+)\s(.+)\))? # optional engine info
-    /xo
+    /xo.freeze
 
     # Returns a RubyVersion from the given string.
     # @param [String] the version string to match.
@@ -74,7 +74,7 @@ module Bundler
       @host ||= [
         RbConfig::CONFIG["host_cpu"],
         RbConfig::CONFIG["host_vendor"],
-        RbConfig::CONFIG["host_os"]
+        RbConfig::CONFIG["host_os"],
       ].join("-")
     end
 
@@ -102,24 +102,9 @@ module Bundler
     end
 
     def self.system
-      ruby_engine = if defined?(RUBY_ENGINE) && !RUBY_ENGINE.nil?
-        RUBY_ENGINE.dup
-      else
-        # not defined in ruby 1.8.7
-        "ruby"
-      end
-      # :sob: mocking RUBY_VERSION breaks stuff on 1.8.7
+      ruby_engine = RUBY_ENGINE.dup
       ruby_version = ENV.fetch("BUNDLER_SPEC_RUBY_VERSION") { RUBY_VERSION }.dup
-      ruby_engine_version = case ruby_engine
-                            when "ruby"
-                              ruby_version
-                            when "rbx"
-                              Rubinius::VERSION.dup
-                            when "jruby"
-                              JRUBY_VERSION.dup
-                            else
-                              RUBY_ENGINE_VERSION.dup
-      end
+      ruby_engine_version = RUBY_ENGINE_VERSION.dup
       patchlevel = RUBY_PATCHLEVEL.to_s
 
       @ruby_version ||= RubyVersion.new(ruby_version, patchlevel, ruby_engine, ruby_engine_version)

data/lib/bundler/rubygems_ext.rb

@@ -2,45 +2,27 @@
 
 require "pathname"
 
-if defined?(Gem::QuickLoader)
-  # Gem Prelude makes me a sad panda :'(
-  Gem::QuickLoader.load_full_rubygems_library
-end
-
 require "rubygems/specification"
 
-begin
-  # Possible use in Gem::Specification#source below and require
-  # shouldn't be deferred.
-  require "rubygems/source"
-rescue LoadError
-  # Not available before RubyGems 2.0.0, ignore
-  nil
-end
+# Possible use in Gem::Specification#source below and require
+# shouldn't be deferred.
+require "rubygems/source"
 
-require "bundler/match_platform"
+require_relative "match_platform"
 
 module Gem
-  @loaded_stacks = Hash.new {|h, k| h[k] = [] }
-
   class Specification
     attr_accessor :remote, :location, :relative_loaded_from
 
-    if instance_methods(false).map(&:to_sym).include?(:source)
-      remove_method :source
-      attr_writer :source
-      def source
-        (defined?(@source) && @source) || Gem::Source::Installed.new
-      end
-    else
-      attr_accessor :source
+    remove_method :source
+    attr_writer :source
+    def source
+      (defined?(@source) && @source) || Gem::Source::Installed.new
     end
 
     alias_method :rg_full_gem_path, :full_gem_path
     alias_method :rg_loaded_from,   :loaded_from
 
-    attr_writer :full_gem_path unless instance_methods.include?(:full_gem_path=)
-
     def full_gem_path
       # this cannot check source.is_a?(Bundler::Plugin::API::Source)
       # because that _could_ trip the autoload, and if there are unresolved
@@ -62,15 +44,7 @@ module Gem
     end
 
     def load_paths
-      return full_require_paths if respond_to?(:full_require_paths)
-
-      require_paths.map do |require_path|
-        if require_path.include?(full_gem_path)
-          require_path
-        else
-          File.join(full_gem_path, require_path)
-        end
-      end
+      full_require_paths
     end
 
     if method_defined?(:extension_dir)
@@ -84,10 +58,7 @@ module Gem
       end
     end
 
-    # RubyGems 1.8+ used only.
-    methods = instance_methods(false)
-    gem_dir = methods.first.is_a?(String) ? "gem_dir" : :gem_dir
-    remove_method :gem_dir if methods.include?(gem_dir)
+    remove_method :gem_dir if instance_methods(false).include?(:gem_dir)
     def gem_dir
       full_gem_path
     end
@@ -157,32 +128,6 @@ module Gem
       end
       out
     end
-
-    # Backport of performance enhancement added to RubyGems 1.4
-    def matches_spec?(spec)
-      # name can be a Regexp, so use ===
-      return false unless name === spec.name
-      return true  if requirement.none?
-
-      requirement.satisfied_by?(spec.version)
-    end unless allocate.respond_to?(:matches_spec?)
-  end
-
-  class Requirement
-    # Backport of performance enhancement added to RubyGems 1.4
-    def none?
-      # 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] == "="
-    end unless allocate.respond_to?(:exact?)
   end
 
   class Platform