bundler 2.0.0.pre.3 → 2.1.0.pre.1

data/lib/bundler/cli/package.rb

@@ -11,7 +11,6 @@ module Bundler
     def run
       Bundler.ui.level = "error" if options[:quiet]
       Bundler.settings.set_command_option_if_given :path, options[:path]
-      Bundler.settings.set_command_option_if_given :cache_all_platforms, options["all-platforms"]
       Bundler.settings.set_command_option_if_given :cache_path, options["cache-path"]
 
       setup_cache_all
@@ -19,30 +18,30 @@ module Bundler
 
       # TODO: move cache contents here now that all bundles are locked
       custom_path = Bundler.settings[:path] if options[:path]
-      Bundler.load.cache(custom_path)
+
+      Bundler.settings.temporary(:cache_all_platforms => options["all-platforms"]) do
+        Bundler.load.cache(custom_path)
+      end
     end
 
   private
 
     def install
-      require "bundler/cli/install"
+      require_relative "install"
       options = self.options.dup
-      if Bundler.settings[:cache_all_platforms]
-        options["local"] = false
-        options["update"] = true
-      end
+      options["local"] = false if Bundler.settings[:cache_all_platforms]
       Bundler::CLI::Install.new(options).run
     end
 
     def setup_cache_all
-      all = options.fetch(:all, Bundler.feature_flag.cache_command_is_package? || nil)
+      all = options.fetch(:all, Bundler.feature_flag.cache_all? || nil)
 
       Bundler.settings.set_command_option_if_given :cache_all, all
 
       if Bundler.definition.has_local_dependencies? && !Bundler.feature_flag.cache_all?
         Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want "    \
           "to package them as well, please pass the --all flag. This will be the default " \
-          "on Bundler 2.0."
+          "on Bundler 3.0."
       end
     end
   end

data/lib/bundler/cli/plugin.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "bundler/vendored_thor"
+require_relative "../vendored_thor"
 module Bundler
   class CLI::Plugin < Thor
     desc "install PLUGINS", "Install the plugin from the source"
     long_desc <<-D
-      Install plugins either from the rubygems source provided (with --source option) or from a git source provided with (--git option). If no sources are provided, it uses Gem.sources
+      Install plugins either from the rubygems source provided (with --source option) or from a git source provided with --git (for remote repos) or --local_git (for local repos). If no sources are provided, it uses Gem.sources
    D
     method_option "source", :type => :string, :default => nil, :banner =>
       "URL of the RubyGems source to fetch the plugin from"
@@ -13,6 +13,8 @@ module Bundler
       "The version of the plugin to fetch"
     method_option "git", :type => :string, :default => nil, :banner =>
       "URL of the git repo to fetch from"
+    method_option "local_git", :type => :string, :default => nil, :banner =>
+      "Path of the local git repo to fetch from"
     method_option "branch", :type => :string, :default => nil, :banner =>
       "The git branch to checkout"
     method_option "ref", :type => :string, :default => nil, :banner =>
@@ -20,5 +22,10 @@ module Bundler
     def install(*plugins)
       Bundler::Plugin.install(plugins, options)
     end
+
+    desc "list", "List the installed plugins and available commands"
+    def list
+      Bundler::Plugin.list
+    end
   end
 end

data/lib/bundler/cli/pristine.rb

@@ -33,7 +33,7 @@ module Bundler
           if extension_cache_path = source.extension_cache_path(spec)
             FileUtils.rm_rf extension_cache_path
           end
-          FileUtils.rm_rf spec.extension_dir if spec.respond_to?(:extension_dir)
+          FileUtils.rm_rf spec.extension_dir
           FileUtils.rm_rf spec.full_gem_path
         else
           Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is sourced from local path.")

data/lib/bundler/cli/show.rb

@@ -24,7 +24,7 @@ module Bundler
           return unless spec
           path = spec.full_gem_path
           unless File.directory?(path)
-            Bundler.ui.warn "The gem #{gem_name} has been deleted. It was installed at:"
+            return Bundler.ui.warn "The gem #{gem_name} has been deleted. It was installed at: #{path}"
           end
         end
         return Bundler.ui.info(path)

data/lib/bundler/cli/update.rb

@@ -22,7 +22,7 @@ module Bundler
         if Bundler.feature_flag.update_requires_all_flag?
           raise InvalidOption, "To update everything, pass the `--all` flag."
         end
-        SharedHelpers.major_deprecation 3, "Pass --all to `bundle update` to update everything"
+        SharedHelpers.major_deprecation 2, "Pass --all to `bundle update` to update everything"
       elsif !full_update && options[:all]
         raise InvalidOption, "Cannot specify --all along with specific options."
       end
@@ -58,24 +58,44 @@ module Bundler
       Bundler.settings.set_command_option_if_given :jobs, opts["jobs"]
 
       Bundler.definition.validate_runtime!
+
+      if locked_gems = Bundler.definition.locked_gems
+        previous_locked_info = locked_gems.specs.reduce({}) do |h, s|
+          h[s.name] = { :spec => s, :version => s.version, :source => s.source.to_s }
+          h
+        end
+      end
+
       installer = Installer.install Bundler.root, Bundler.definition, opts
       Bundler.load.cache if Bundler.app_cache.exist?
 
       if CLI::Common.clean_after_install?
-        require "bundler/cli/clean"
+        require_relative "clean"
         Bundler::CLI::Clean.new(options).run
       end
 
-      if locked_gems = Bundler.definition.locked_gems
+      if locked_gems
         gems.each do |name|
-          locked_version = locked_gems.specs.find {|s| s.name == name }
-          locked_version &&= locked_version.version
-          next unless locked_version
-          new_version = Bundler.definition.specs[name].first
-          new_version &&= new_version.version
-          if !new_version
-            Bundler.ui.warn "Bundler attempted to update #{name} but it was removed from the bundle"
-          elsif new_version < locked_version
+          locked_info = previous_locked_info[name]
+          next unless locked_info
+
+          locked_spec = locked_info[:spec]
+          new_spec = Bundler.definition.specs[name].first
+          unless new_spec
+            if Bundler.rubygems.platforms.none? {|p| locked_spec.match_platform(p) }
+              Bundler.ui.warn "Bundler attempted to update #{name} but it was not considered because it is for a different platform from the current one"
+            end
+
+            next
+          end
+
+          locked_source = locked_info[:source]
+          new_source = new_spec.source.to_s
+          next if locked_source != new_source
+
+          new_version = new_spec.version
+          locked_version = locked_info[:version]
+          if new_version < locked_version
             Bundler.ui.warn "Note: #{name} version regressed from #{locked_version} to #{new_version}"
           elsif new_version == locked_version
             Bundler.ui.warn "Bundler attempted to update #{name} but its version stayed the same"
@@ -84,7 +104,7 @@ module Bundler
       end
 
       Bundler.ui.confirm "Bundle updated!"
-      Bundler::CLI::Common.output_without_groups_message
+      Bundler::CLI::Common.output_without_groups_message(:update)
       Bundler::CLI::Common.output_post_install_messages installer.post_install_messages
     end
   end

data/lib/bundler/compact_index_client.rb

@@ -13,16 +13,11 @@ module Bundler
 
     class Error < StandardError; end
 
-    require "bundler/compact_index_client/cache"
-    require "bundler/compact_index_client/updater"
+    require_relative "compact_index_client/cache"
+    require_relative "compact_index_client/updater"
 
     attr_reader :directory
 
-    # @return [Lambda] A lambda that takes an array of inputs and a block, and
-    #         maps the inputs with the block in parallel.
-    #
-    attr_accessor :in_parallel
-
     def initialize(directory, fetcher)
       @directory = Pathname.new(directory)
       @updater = Updater.new(fetcher)
@@ -31,7 +26,28 @@ module Bundler
       @info_checksums_by_name = {}
       @parsed_checksums = false
       @mutex = Mutex.new
-      @in_parallel = lambda do |inputs, &blk|
+    end
+
+    def execution_mode=(block)
+      Bundler::CompactIndexClient.debug { "execution_mode=" }
+      @endpoints = Set.new
+
+      @execution_mode = block
+    end
+
+    # @return [Lambda] A lambda that takes an array of inputs and a block, and
+    #         maps the inputs with the block in parallel.
+    #
+    def execution_mode
+      @execution_mode || sequentially
+    end
+
+    def sequential_execution_mode!
+      self.execution_mode = sequentially
+    end
+
+    def sequentially
+      @sequentially ||= lambda do |inputs, &blk|
         inputs.map(&blk)
       end
     end
@@ -51,7 +67,7 @@ module Bundler
 
     def dependencies(names)
       Bundler::CompactIndexClient.debug { "dependencies(#{names})" }
-      in_parallel.call(names) do |name|
+      execution_mode.call(names) do |name|
         update_info(name)
         @cache.dependencies(name).map {|d| d.unshift(name) }
       end.flatten(1)

data/lib/bundler/compact_index_client/updater.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "bundler/vendored_fileutils"
+require_relative "../vendored_fileutils"
 require "stringio"
 require "zlib"
 
@@ -95,11 +95,7 @@ module Bundler
       end
 
       def slice_body(body, range)
-        if body.respond_to?(:byteslice)
-          body.byteslice(range)
-        else # pre-1.9.3
-          body.unpack("@#{range.first}a#{range.end + 1}").first
-        end
+        body.byteslice(range)
       end
 
       def checksum_for_file(path)

data/lib/bundler/current_ruby.rb

@@ -38,28 +38,29 @@ module Bundler
     ].freeze
 
     def ruby?
-      !mswin? && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" ||
-          RUBY_ENGINE == "rbx" || RUBY_ENGINE == "maglev" || RUBY_ENGINE == "truffleruby")
+      return true if Bundler::GemHelpers.generic_local_platform == Gem::Platform::RUBY
+
+      !mswin? && (RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx" || RUBY_ENGINE == "maglev" || RUBY_ENGINE == "truffleruby")
     end
 
     def mri?
-      !mswin? && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby")
+      !mswin? && RUBY_ENGINE == "ruby"
     end
 
     def rbx?
-      ruby? && defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+      ruby? && RUBY_ENGINE == "rbx"
     end
 
     def jruby?
-      defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+      RUBY_ENGINE == "jruby"
     end
 
     def maglev?
-      defined?(RUBY_ENGINE) && RUBY_ENGINE == "maglev"
+      RUBY_ENGINE == "maglev"
     end
 
     def truffleruby?
-      defined?(RUBY_ENGINE) && RUBY_ENGINE == "truffleruby"
+      RUBY_ENGINE == "truffleruby"
     end
 
     def mswin?

data/lib/bundler/definition.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "bundler/lockfile_parser"
+require_relative "lockfile_parser"
 require "set"
 
 module Bundler
@@ -167,7 +167,7 @@ module Bundler
     def specs
       @specs ||= begin
         begin
-          specs = resolve.materialize(Bundler.settings[:cache_all_platforms] ? dependencies : requested_dependencies)
+          specs = resolve.materialize(requested_dependencies)
         rescue GemNotFound => e # Handle yanked gem
           gem_name, gem_version = extract_gem_info(e)
           locked_gem = @locked_specs[gem_name].last
@@ -317,7 +317,7 @@ module Bundler
     end
 
     def spec_git_paths
-      sources.git_sources.map {|s| s.path.to_s }
+      sources.git_sources.map {|s| File.realpath(s.path) }
     end
 
     def groups
@@ -331,7 +331,7 @@ module Bundler
       # i.e., Windows with `git config core.autocrlf=true`
       contents.gsub!(/\n/, "\r\n") if @lockfile_contents.match("\r\n")
 
-      if @locked_bundler_version && Bundler.feature_flag.lockfile_upgrade_warning?
+      if @locked_bundler_version
         locked_major = @locked_bundler_version.segments.first
         current_major = Gem::Version.create(Bundler::VERSION).segments.first
 
@@ -385,7 +385,7 @@ module Bundler
     end
 
     def to_lock
-      require "bundler/lockfile_generator"
+      require_relative "lockfile_generator"
       LockfileGenerator.generate(self)
     end
 
@@ -397,9 +397,9 @@ module Bundler
 
       unless explicit_flag
         suggested_command = if Bundler.settings.locations("frozen")[:global]
-          "bundle config --delete frozen"
+          "bundle config unset frozen"
         elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any?
-          "bundle config --delete deployment"
+          "bundle config unset deployment"
         else
           "bundle install --no-deployment"
         end
@@ -519,9 +519,7 @@ module Bundler
     end
 
     def add_current_platform
-      current_platform = Bundler.local_platform
-      add_platform(current_platform) if Bundler.feature_flag.specific_platform?
-      add_platform(generic(current_platform))
+      current_platforms.each {|platform| add_platform(platform) }
     end
 
     def find_resolved_spec(current_spec)
@@ -545,6 +543,14 @@ module Bundler
 
   private
 
+    def current_platforms
+      current_platform = Bundler.local_platform
+      [].tap do |platforms|
+        platforms << current_platform if Bundler.feature_flag.specific_platform?
+        platforms << generic(current_platform)
+      end
+    end
+
     def change_reason
       if unlocking?
         unlock_reason = @unlock.reject {|_k, v| Array(v).empty? }.map do |k, v|
@@ -643,7 +649,7 @@ module Bundler
     end
 
     def converge_rubygems_sources
-      return false if Bundler.feature_flag.lockfile_uses_separate_rubygems_sources?
+      return false if Bundler.feature_flag.disable_multisource?
 
       changes = false
 
@@ -782,7 +788,7 @@ module Bundler
 
         # Path sources have special logic
         if s.source.instance_of?(Source::Path) || s.source.instance_of?(Source::Gemspec)
-          other_sources_specs = begin
+          new_specs = begin
             s.source.specs
           rescue PathError, GitError
             # if we won't need the source (according to the lockfile),
@@ -794,25 +800,26 @@ module Bundler
             raise
           end
 
-          other = other_sources_specs[s].first
+          new_spec = new_specs[s].first
 
           # If the spec is no longer in the path source, unlock it. This
           # commonly happens if the version changed in the gemspec
-          next unless other
+          next unless new_spec
+
+          new_runtime_deps = new_spec.dependencies.select {|d| d.type != :development }
+          old_runtime_deps = s.dependencies.select {|d| d.type != :development }
+          # If the dependencies of the path source have changed and locked spec can't satisfy new dependencies, unlock it
+          next unless new_runtime_deps.sort == old_runtime_deps.sort || new_runtime_deps.all? {|d| satisfies_locked_spec?(d) }
 
-          deps2 = other.dependencies.select {|d| d.type != :development }
-          runtime_dependencies = s.dependencies.select {|d| d.type != :development }
-          # If the dependencies of the path source have changed, unlock it
-          next unless runtime_dependencies.sort == deps2.sort
+          s.dependencies.replace(new_spec.dependencies)
         end
 
         converged << s
       end
 
       resolve = SpecSet.new(converged)
-      expanded_deps = expand_dependencies(deps, true)
-      @locked_specs_incomplete_for_platform = !resolve.for(expanded_deps, @unlock[:gems], true, true)
-      resolve = resolve.for(expanded_deps, @unlock[:gems], false, false, false)
+      @locked_specs_incomplete_for_platform = !resolve.for(expand_dependencies(deps), @unlock[:gems], true, true)
+      resolve = resolve.for(expand_dependencies(deps, true), @unlock[:gems], false, false, false)
       diff    = nil
 
       # Now, we unlock any sources that do not have anymore gems pinned to it
@@ -855,8 +862,8 @@ module Bundler
           concat_ruby_version_requirements(locked_ruby_version_object) unless @unlock[:ruby]
         end
         [
-          Dependency.new("ruby\0", ruby_versions),
-          Dependency.new("rubygems\0", Gem::VERSION),
+          Dependency.new("Ruby\0", ruby_versions),
+          Dependency.new("RubyGems\0", Gem::VERSION),
         ]
       end
     end
@@ -885,7 +892,7 @@ module Bundler
         next if !remote && !dep.current_platform?
         platforms = dep.gem_platforms(sorted_platforms)
         if platforms.empty? && !Bundler.settings[:disable_platform_warnings]
-          mapped_platforms = dep.platforms.map {|p| Dependency::PLATFORM_MAP[p] }
+          mapped_platforms = dep.expanded_platforms
           Bundler.ui.warn \
             "The dependency #{dep} will be unused by any of the platforms Bundler is installing for. " \
             "Bundler is installing for #{@platforms.join ", "} but the dependency " \
@@ -915,7 +922,7 @@ module Bundler
       # look for that gemspec (or its dependencies)
       default = sources.default_source
       source_requirements = { :default => default }
-      default = nil unless Bundler.feature_flag.lockfile_uses_separate_rubygems_sources?
+      default = nil unless Bundler.feature_flag.disable_multisource?
       dependencies.each do |dep|
         next unless source = dep.source || default
         source_requirements[dep.name] = source
@@ -929,7 +936,7 @@ module Bundler
 
     def pinned_spec_names(skip = nil)
       pinned_names = []
-      default = Bundler.feature_flag.lockfile_uses_separate_rubygems_sources? && sources.default_source
+      default = Bundler.feature_flag.disable_multisource? && sources.default_source
       @dependencies.each do |dep|
         next unless dep_source = dep.source || default
         next if dep_source == skip
@@ -977,7 +984,9 @@ module Bundler
       dependencies_by_name = dependencies.inject({}) {|memo, dep| memo.update(dep.name => dep) }
       @locked_gems.specs.reduce({}) do |requirements, locked_spec|
         name = locked_spec.name
-        next requirements if @locked_gems.dependencies[name] != dependencies_by_name[name]
+        dependency = dependencies_by_name[name]
+        next requirements if @locked_gems.dependencies[name] != dependency
+        next requirements if dependency && dependency.source.is_a?(Source::Path)
         dep = Gem::Dependency.new(name, ">= #{locked_spec.version}")
         requirements[name] = DepProxy.new(dep, locked_spec.platform)
         requirements