bundler 1.15.1 → 1.17.3

data/lib/bundler/cli/install.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "bundler/cli/common"
 
 module Bundler
   class CLI::Install
@@ -13,19 +12,9 @@ module Bundler
 
       warn_if_root
 
-      warn_if_outdated
-
-      [:with, :without].each do |option|
-        if options[option]
-          options[option] = options[option].join(":").tr(" ", ":").split(":")
-        end
-      end
-
-      check_for_group_conflicts
-
       normalize_groups
 
-      ENV["RB_USER_INSTALL"] = "1" if Bundler::FREEBSD
+      Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Bundler::FREEBSD
 
       # Disable color in deployment mode
       Bundler.ui.shell = Thor::Shell::Basic.new if options[:deployment]
@@ -34,22 +23,28 @@ module Bundler
 
       check_trust_policy
 
-      if options[:deployment] || options[:frozen]
+      if options[:deployment] || options[:frozen] || Bundler.frozen_bundle?
         unless Bundler.default_lockfile.exist?
-          flag = options[:deployment] ? "--deployment" : "--frozen"
-          raise ProductionError, "The #{flag} flag requires a #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}. Please make " \
+          flag   = "--deployment flag" if options[:deployment]
+          flag ||= "--frozen flag"     if options[:frozen]
+          flag ||= "deployment setting"
+          raise ProductionError, "The #{flag} requires a #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}. Please make " \
                                  "sure you have checked your #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} into version control " \
                                  "before deploying."
         end
 
         options[:local] = true if Bundler.app_cache.exist?
 
-        Bundler.settings[:frozen] = "1"
+        if Bundler.feature_flag.deployment_means_frozen?
+          Bundler.settings.set_command_option :deployment, true
+        else
+          Bundler.settings.set_command_option :frozen, true
+        end
       end
 
       # When install is called with --no-deployment, disable deployment mode
       if options[:deployment] == false
-        Bundler.settings.delete(:frozen)
+        Bundler.settings.set_command_option :frozen, nil
         options[:system] = true
       end
 
@@ -58,7 +53,7 @@ module Bundler
       Bundler::Fetcher.disable_endpoint = options["full-index"]
 
       if options["binstubs"]
-        Bundler::SharedHelpers.major_deprecation \
+        Bundler::SharedHelpers.major_deprecation 2,
           "The --binstubs option will be removed in favor of `bundle binstubs`"
       end
 
@@ -68,24 +63,23 @@ module Bundler
       definition.validate_runtime!
 
       installer = Installer.install(Bundler.root, definition, options)
-      Bundler.load.cache if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.settings[:frozen]
+      Bundler.load.cache if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.frozen_bundle?
 
       Bundler.ui.confirm "Bundle complete! #{dependencies_count_for(definition)}, #{gems_installed_for(definition)}."
       Bundler::CLI::Common.output_without_groups_message
 
-      if Bundler.settings[:path]
-        absolute_path = File.expand_path(Bundler.settings[:path])
-        relative_path = absolute_path.sub(File.expand_path(".") + File::SEPARATOR, "." + File::SEPARATOR)
-        Bundler.ui.confirm "Bundled gems are installed into #{relative_path}."
-      else
+      if Bundler.use_system_gems?
         Bundler.ui.confirm "Use `bundle info [gemname]` to see where a bundled gem is installed."
+      else
+        relative_path = Bundler.configured_bundle_path.base_path_relative_to_pwd
+        Bundler.ui.confirm "Bundled gems are installed into `#{relative_path}`"
       end
 
       Bundler::CLI::Common.output_post_install_messages installer.post_install_messages
 
       warn_ambiguous_gems
 
-      if Bundler.settings[:clean] && Bundler.settings[:path]
+      if CLI::Common.clean_after_install?
         require "bundler/cli/clean"
         Bundler::CLI::Clean.new(options).run
       end
@@ -116,20 +110,6 @@ module Bundler
         "application for all non-root users on this machine.", :wrap => true
     end
 
-    def warn_if_outdated
-      return if ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"].nil?
-      installed_version = Gem::Version.new(ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"].dup)
-      running_version = Gem::Version.new(Bundler::VERSION)
-      return if Gem::Requirement.new(installed_version).satisfied_by?(running_version)
-      if Bundler.settings[:warned_version].nil? || running_version > Gem::Version.new(Bundler.settings[:warned_version])
-        Bundler.settings[:warned_version] = running_version
-        Bundler.ui.warn "You're running Bundler #{installed_version} but this " \
-          "project uses #{running_version}. To update, run `bundle update " \
-          "--bundler`. You won't see this message again unless you upgrade " \
-          "to a newer version of Bundler.", :wrap => true
-      end
-    end
-
     def dependencies_count_for(definition)
       count = definition.dependencies.count
       "#{count} Gemfile #{count == 1 ? "dependency" : "dependencies"}"
@@ -140,15 +120,11 @@ module Bundler
       "#{count} #{count == 1 ? "gem" : "gems"} now installed"
     end
 
-    def check_for_group_conflicts
-      if options[:without] && options[:with]
-        conflicting_groups = options[:without] & options[:with]
-        unless conflicting_groups.empty?
-          Bundler.ui.error "You can't list a group in both, --with and --without." \
-          "The offending groups are: #{conflicting_groups.join(", ")}."
-          exit 1
-        end
-      end
+    def check_for_group_conflicts_in_cli_options
+      conflicting_groups = Array(options[:without]) & Array(options[:with])
+      return if conflicting_groups.empty?
+      raise InvalidOption, "You can't list a group in both with and without." \
+        " The offending groups are: #{conflicting_groups.join(", ")}."
     end
 
     def check_for_options_conflicts
@@ -161,28 +137,29 @@ module Bundler
     end
 
     def check_trust_policy
-      if options["trust-policy"]
-        unless Bundler.rubygems.security_policies.keys.include?(options["trust-policy"])
-          Bundler.ui.error "Rubygems doesn't know about trust policy '#{options["trust-policy"]}'. " \
-            "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
-          exit 1
-        end
-        Bundler.settings["trust-policy"] = options["trust-policy"]
-      else
-        Bundler.settings["trust-policy"] = nil if Bundler.settings["trust-policy"]
+      trust_policy = options["trust-policy"]
+      unless Bundler.rubygems.security_policies.keys.unshift(nil).include?(trust_policy)
+        raise InvalidOption, "RubyGems doesn't know about trust policy '#{trust_policy}'. " \
+          "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
       end
+      Bundler.settings.set_command_option_if_given :"trust-policy", trust_policy
     end
 
     def normalize_groups
-      Bundler.settings.with    = [] if options[:with] && options[:with].empty?
-      Bundler.settings.without = [] if options[:without] && options[:without].empty?
+      options[:with] &&= options[:with].join(":").tr(" ", ":").split(":")
+      options[:without] &&= options[:without].join(":").tr(" ", ":").split(":")
 
-      with = options.fetch("with", [])
-      with |= Bundler.settings.with.map(&:to_s)
+      check_for_group_conflicts_in_cli_options
+
+      Bundler.settings.set_command_option :with, nil if options[:with] == []
+      Bundler.settings.set_command_option :without, nil if options[:without] == []
+
+      with = options.fetch(:with, [])
+      with |= Bundler.settings[:with].map(&:to_s)
       with -= options[:without] if options[:without]
 
-      without = options.fetch("without", [])
-      without |= Bundler.settings.without.map(&:to_s)
+      without = options.fetch(:without, [])
+      without |= Bundler.settings[:without].map(&:to_s)
       without -= options[:with] if options[:with]
 
       options[:with]    = with
@@ -190,28 +167,38 @@ module Bundler
     end
 
     def normalize_settings
-      Bundler.settings[:path]                = nil if options[:system]
-      Bundler.settings[:path]                = "vendor/bundle" if options[:deployment]
-      Bundler.settings[:path]                = options["path"] if options["path"]
-      Bundler.settings[:path]              ||= "bundle" if options["standalone"]
+      Bundler.settings.set_command_option :path, nil if options[:system]
+      Bundler.settings.temporary(:path_relative_to_cwd => false) do
+        Bundler.settings.set_command_option :path, "vendor/bundle" if options[:deployment]
+      end
+      Bundler.settings.set_command_option_if_given :path, options[:path]
+      Bundler.settings.temporary(:path_relative_to_cwd => false) do
+        Bundler.settings.set_command_option :path, "bundle" if options["standalone"] && Bundler.settings[:path].nil?
+      end
 
-      Bundler.settings[:bin]                 = options["binstubs"] if options["binstubs"]
-      Bundler.settings[:bin]                 = nil if options["binstubs"] && options["binstubs"].empty?
+      bin_option = options["binstubs"]
+      bin_option = nil if bin_option && bin_option.empty?
+      Bundler.settings.set_command_option :bin, bin_option if options["binstubs"]
 
-      Bundler.settings[:shebang]             = options["shebang"] if options["shebang"]
+      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
 
-      Bundler.settings[:jobs]                = options["jobs"] if options["jobs"]
+      Bundler.settings.set_command_option_if_given :jobs, options["jobs"]
 
-      Bundler.settings[:no_prune]            = true if options["no-prune"]
+      Bundler.settings.set_command_option_if_given :no_prune, options["no-prune"]
 
-      Bundler.settings[:no_install]          = true if options["no-install"]
+      Bundler.settings.set_command_option_if_given :no_install, options["no-install"]
 
-      Bundler.settings[:clean]               = options["clean"] if options["clean"]
+      Bundler.settings.set_command_option_if_given :clean, options["clean"]
 
-      Bundler.settings.without               = options[:without]
-      Bundler.settings.with                  = options[:with]
+      unless Bundler.settings[:without] == options[:without] && Bundler.settings[:with] == options[:with]
+        # need to nil them out first to get around validation for backwards compatibility
+        Bundler.settings.set_command_option :without, nil
+        Bundler.settings.set_command_option :with,    nil
+        Bundler.settings.set_command_option :without, options[:without] - options[:with]
+        Bundler.settings.set_command_option :with,    options[:with]
+      end
 
-      Bundler.settings[:disable_shared_gems] = Bundler.settings[:path] ? true : nil
+      options[:force] = options[:redownload]
     end
 
     def warn_ambiguous_gems

data/lib/bundler/cli/issue.rb

@@ -26,7 +26,7 @@ module Bundler
 
       EOS
 
-      Bundler.ui.info Bundler::Env.new.report
+      Bundler.ui.info Bundler::Env.report
 
       Bundler.ui.info "\n## Bundle Doctor"
       doctor

data/lib/bundler/cli/list.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::List
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      raise InvalidOption, "The `--only-group` and `--without-group` options cannot be used together" if @options["only-group"] && @options["without-group"]
+
+      raise InvalidOption, "The `--name-only` and `--paths` options cannot be used together" if @options["name-only"] && @options[:paths]
+
+      specs = if @options["only-group"] || @options["without-group"]
+        filtered_specs_by_groups
+      else
+        Bundler.load.specs
+      end.reject {|s| s.name == "bundler" }.sort_by(&:name)
+
+      return Bundler.ui.info "No gems in the Gemfile" if specs.empty?
+
+      return specs.each {|s| Bundler.ui.info s.name } if @options["name-only"]
+      return specs.each {|s| Bundler.ui.info s.full_gem_path } if @options["paths"]
+
+      Bundler.ui.info "Gems included by the bundle:"
+
+      specs.each {|s| Bundler.ui.info "  * #{s.name} (#{s.version}#{s.git_version})" }
+
+      Bundler.ui.info "Use `bundle info` to print more detailed information about a gem"
+    end
+
+  private
+
+    def verify_group_exists(groups)
+      raise InvalidOption, "`#{@options["without-group"]}` group could not be found." if @options["without-group"] && !groups.include?(@options["without-group"].to_sym)
+
+      raise InvalidOption, "`#{@options["only-group"]}` group could not be found." if @options["only-group"] && !groups.include?(@options["only-group"].to_sym)
+    end
+
+    def filtered_specs_by_groups
+      definition = Bundler.definition
+      groups = definition.groups
+
+      verify_group_exists(groups)
+
+      show_groups =
+        if @options["without-group"]
+          groups.reject {|g| g == @options["without-group"].to_sym }
+        elsif @options["only-group"]
+          groups.select {|g| g == @options["only-group"].to_sym }
+        else
+          groups
+        end.map(&:to_sym)
+
+      definition.specs_for(show_groups)
+    end
+  end
+end

data/lib/bundler/cli/lock.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "bundler/cli/common"
 
 module Bundler
   class CLI::Lock

data/lib/bundler/cli/open.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require "bundler/cli/common"
+
 require "shellwords"
 
 module Bundler
@@ -17,7 +17,7 @@ module Bundler
       path = spec.full_gem_path
       Dir.chdir(path) do
         command = Shellwords.split(editor) + [path]
-        Bundler.with_clean_env do
+        Bundler.with_original_env do
           system(*command)
         end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
       end

data/lib/bundler/cli/outdated.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "bundler/cli/common"
 
 module Bundler
   class CLI::Outdated
@@ -46,7 +45,7 @@ module Bundler
         Bundler::CLI::Common.patch_level_options(options).any?
 
       filter_options_patch = options.keys &
-        %w(filter-major filter-minor filter-patch)
+        %w[filter-major filter-minor filter-patch]
 
       definition_resolution = proc do
         options[:local] ? definition.resolve_with_cache! : definition.resolve_remotely!
@@ -67,7 +66,13 @@ module Bundler
         current_dependencies.key? spec.name
       end
 
-      (gemfile_specs + dependency_specs).sort_by(&:name).each do |current_spec|
+      specs = if options["only-explicit"]
+        gemfile_specs
+      else
+        gemfile_specs + dependency_specs
+      end
+
+      specs.sort_by(&:name).each do |current_spec|
         next if !gems.empty? && !gems.include?(current_spec.name)
 
         dependency = current_dependencies[current_spec.name]
@@ -214,13 +219,19 @@ module Bundler
     end
 
     def check_for_deployment_mode
-      if Bundler.settings[:frozen]
-        raise ProductionError, "You are trying to check outdated gems in " \
-          "deployment mode. Run `bundle outdated` elsewhere.\n" \
-          "\nIf this is a development machine, remove the " \
-          "#{Bundler.default_gemfile} freeze" \
-          "\nby running `bundle install --no-deployment`."
+      return unless Bundler.frozen_bundle?
+      suggested_command = if Bundler.settings.locations("frozen")[:global]
+        "bundle config --delete frozen"
+      elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any?
+        "bundle config --delete deployment"
+      else
+        "bundle install --no-deployment"
       end
+      raise ProductionError, "You are trying to check outdated gems in " \
+        "deployment mode. Run `bundle outdated` elsewhere.\n" \
+        "\nIf this is a development machine, remove the " \
+        "#{Bundler.default_gemfile} freeze" \
+        "\nby running `#{suggested_command}`."
     end
 
     def update_present_via_semver_portions(current_spec, active_spec, options)

data/lib/bundler/cli/package.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Bundler
   class CLI::Package
     attr_reader :options
@@ -9,15 +10,15 @@ module Bundler
 
     def run
       Bundler.ui.level = "error" if options[:quiet]
-      Bundler.settings[:path] = File.expand_path(options[:path]) if options[:path]
-      Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")
-      Bundler.settings[:cache_path] = options["cache-path"] if options.key?("cache-path")
+      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
       install
 
       # TODO: move cache contents here now that all bundles are locked
-      custom_path = Pathname.new(options[:path]) if options[:path]
+      custom_path = Bundler.settings[:path] if options[:path]
       Bundler.load.cache(custom_path)
     end
 
@@ -34,9 +35,11 @@ module Bundler
     end
 
     def setup_cache_all
-      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+      all = options.fetch(:all, Bundler.feature_flag.cache_command_is_package? || nil)
+
+      Bundler.settings.set_command_option_if_given :cache_all, all
 
-      if Bundler.definition.has_local_dependencies? && !Bundler.settings[:cache_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."

data/lib/bundler/cli/platform.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Bundler
   class CLI::Platform
     attr_reader :options

data/lib/bundler/cli/plugin.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "bundler/vendored_thor"
 module Bundler
   class CLI::Plugin < Thor

data/lib/bundler/cli/pristine.rb

@@ -1,16 +1,25 @@
 # frozen_string_literal: true
-require "bundler/cli/common"
 
 module Bundler
   class CLI::Pristine
+    def initialize(gems)
+      @gems = gems
+    end
+
     def run
+      CLI::Common.ensure_all_gems_in_lockfile!(@gems)
+      definition = Bundler.definition
+      definition.validate_runtime!
+      installer = Bundler::Installer.new(Bundler.root, definition)
+
       Bundler.load.specs.each do |spec|
         next if spec.name == "bundler" # Source::Rubygems doesn't install bundler
+        next if !@gems.empty? && !@gems.include?(spec.name)
 
         gem_name = "#{spec.name} (#{spec.version}#{spec.git_version})"
         gem_name += " (#{spec.platform})" if !spec.platform.nil? && spec.platform != Gem::Platform::RUBY
 
-        case spec.source
+        case source = spec.source
         when Source::Rubygems
           cached_gem = spec.cache_file
           unless File.exist?(cached_gem)
@@ -19,14 +28,19 @@ module Bundler
           end
 
           FileUtils.rm_rf spec.full_gem_path
-          spec.source.install(spec, :force => true)
         when Source::Git
-          git_source = spec.source
-          git_source.remote!
-          git_source.install(spec, :force => true)
+          source.remote!
+          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.full_gem_path
         else
           Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is sourced from local path.")
+          next
         end
+
+        Bundler::GemInstaller.new(spec, installer, false, 0, true).install_from_spec
       end
     end
   end

data/lib/bundler/cli/remove.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Remove
+    def initialize(gems, options)
+      @gems = gems
+      @options = options
+    end
+
+    def run
+      raise InvalidOption, "Please specify gems to remove." if @gems.empty?
+
+      Injector.remove(@gems, {})
+
+      Installer.install(Bundler.root, Bundler.definition) if @options["install"]
+    end
+  end
+end

data/lib/bundler/cli/show.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "bundler/cli/common"
 
 module Bundler
   class CLI::Show

data/lib/bundler/cli/update.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "bundler/cli/common"
 
 module Bundler
   class CLI::Update
@@ -17,7 +16,18 @@ module Bundler
       sources = Array(options[:source])
       groups  = Array(options[:group]).map(&:to_sym)
 
-      if gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !options[:bundler]
+      full_update = gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !options[:bundler]
+
+      if full_update && !options[:all]
+        if Bundler.feature_flag.update_requires_all_flag?
+          raise InvalidOption, "To update everything, pass the `--all` flag."
+        end
+        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
+
+      if full_update
         # We're doing a full update
         Bundler.definition(true)
       else
@@ -28,12 +38,13 @@ module Bundler
         Bundler::CLI::Common.ensure_all_gems_in_lockfile!(gems)
 
         if groups.any?
-          specs = Bundler.definition.specs_for groups
-          gems.concat(specs.map(&:name))
+          deps = Bundler.definition.dependencies.select {|d| (d.groups & groups).any? }
+          gems.concat(deps.map(&:name))
         end
 
         Bundler.definition(:gems => gems, :sources => sources, :ruby => options[:ruby],
-                           :lock_shared_dependencies => options[:conservative])
+                           :lock_shared_dependencies => options[:conservative],
+                           :bundler => options[:bundler])
       end
 
       Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options)
@@ -44,17 +55,34 @@ module Bundler
       opts["update"] = true
       opts["local"] = options[:local]
 
-      Bundler.settings[:jobs] = opts["jobs"] if opts["jobs"]
+      Bundler.settings.set_command_option_if_given :jobs, opts["jobs"]
 
       Bundler.definition.validate_runtime!
       installer = Installer.install Bundler.root, Bundler.definition, opts
       Bundler.load.cache if Bundler.app_cache.exist?
 
-      if Bundler.settings[:clean] && Bundler.settings[:path]
+      if CLI::Common.clean_after_install?
         require "bundler/cli/clean"
         Bundler::CLI::Clean.new(options).run
       end
 
+      if locked_gems = Bundler.definition.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
+            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"
+          end
+        end
+      end
+
       Bundler.ui.confirm "Bundle updated!"
       Bundler::CLI::Common.output_without_groups_message
       Bundler::CLI::Common.output_post_install_messages installer.post_install_messages

data/lib/bundler/cli/viz.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Bundler
   class CLI::Viz
     attr_reader :options, :gem_name
@@ -7,6 +8,9 @@ module Bundler
     end
 
     def run
+      # make sure we get the right `graphviz`. There is also a `graphviz`
+      # gem we're not built to support
+      gem "ruby-graphviz"
       require "graphviz"
 
       options[:without] = options[:without].join(":").tr(" ", ":").split(":")