bundler 1.11.1 → 2.2.6

data/lib/bundler/cli/add.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Add
+    attr_reader :gems, :options, :version
+
+    def initialize(options, gems)
+      @gems = gems
+      @options = options
+      @options[:group] = options[:group].split(",").map(&:strip) unless options[:group].nil?
+      @version = options[:version].split(",").map(&:strip) unless options[:version].nil?
+    end
+
+    def run
+      validate_options!
+      inject_dependencies
+      perform_bundle_install unless options["skip-install"]
+    end
+
+    private
+
+    def perform_bundle_install
+      Installer.install(Bundler.root, Bundler.definition)
+      Bundler.load.cache if Bundler.app_cache.exist?
+    end
+
+    def inject_dependencies
+      dependencies = gems.map {|g| Bundler::Dependency.new(g, version, options) }
+
+      Injector.inject(dependencies,
+        :conservative_versioning => options[:version].nil?, # Perform conservative versioning only when version is not specified
+        :optimistic => options[:optimistic],
+        :strict => options[:strict])
+    end
+
+    def validate_options!
+      raise InvalidOption, "You can not specify `--strict` and `--optimistic` at the same time." if options[:strict] && options[:optimistic]
+
+      # raise error when no gems are specified
+      raise InvalidOption, "Please specify gems to add." if gems.empty?
+
+      version.to_a.each do |v|
+        raise InvalidOption, "Invalid gem requirement pattern '#{v}'" unless Gem::Requirement::PATTERN =~ v.to_s
+      end
+    end
+  end
+end

data/lib/bundler/cli/binstubs.rb

@@ -1,4 +1,4 @@
-require "bundler/cli/common"
+# frozen_string_literal: true
 
 module Bundler
   class CLI::Binstubs
@@ -9,27 +9,43 @@ module Bundler
     end
 
     def run
-      Bundler.definition.validate_ruby!
-      Bundler.settings[:bin] = options["path"] if options["path"]
-      Bundler.settings[:bin] = nil if options["path"] && options["path"].empty?
+      Bundler.definition.validate_runtime!
+      path_option = options["path"]
+      path_option = nil if path_option && path_option.empty?
+      Bundler.settings.set_command_option :bin, path_option if options["path"]
+      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
       installer = Installer.new(Bundler.root, Bundler.definition)
 
-      if gems.empty?
+      installer_opts = {
+        :force => options[:force],
+        :binstubs_cmd => true,
+        :all_platforms => options["all-platforms"],
+      }
+
+      if options[:all]
+        raise InvalidOption, "Cannot specify --all with specific gems" unless gems.empty?
+        @gems = Bundler.definition.specs.map(&:name)
+        installer_opts.delete(:binstubs_cmd)
+      elsif gems.empty?
         Bundler.ui.error "`bundle binstubs` needs at least one gem to run."
         exit 1
       end
 
       gems.each do |gem_name|
-        spec = installer.specs.find {|s| s.name == gem_name }
+        spec = Bundler.definition.specs.find {|s| s.name == gem_name }
         unless spec
           raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(
-            gem_name, Bundler.definition.specs)
+            gem_name, Bundler.definition.specs
+          )
         end
 
-        if spec.name == "bundler"
-          Bundler.ui.warn "Sorry, Bundler can only be run via Rubygems."
+        if options[:standalone]
+          next Bundler.ui.warn("Sorry, Bundler can only be run via RubyGems.") if gem_name == "bundler"
+          Bundler.settings.temporary(:path => (Bundler.settings[:path] || Bundler.root)) do
+            installer.generate_standalone_bundler_executable_stubs(spec, installer_opts)
+          end
         else
-          installer.generate_bundler_executable_stubs(spec, :force => options[:force], :binstubs_cmd => true)
+          installer.generate_bundler_executable_stubs(spec, installer_opts)
         end
       end
     end

data/lib/bundler/cli/cache.rb

@@ -1,34 +1,42 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Cache
     attr_reader :options
+
     def initialize(options)
       @options = options
     end
 
     def run
-      Bundler.definition.validate_ruby!
-      Bundler.definition.resolve_with_cache!
+      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_path, options["cache-path"]
+
       setup_cache_all
-      Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")
-      Bundler.load.cache
-      Bundler.settings[:no_prune] = true if options["no-prune"]
-      Bundler.load.lock
-    rescue GemNotFound => e
-      Bundler.ui.error(e.message)
-      Bundler.ui.warn "Run `bundle install` to install missing gems."
-      exit 1
+      install
+
+      # TODO: move cache contents here now that all bundles are locked
+      custom_path = Bundler.settings[:path] if options[:path]
+
+      Bundler.settings.temporary(:cache_all_platforms => options["all-platforms"]) do
+        Bundler.load.cache(custom_path)
+      end
     end
 
-  private
+    private
+
+    def install
+      require_relative "install"
+      options = self.options.dup
+      options["local"] = false if Bundler.settings[:cache_all_platforms]
+      Bundler::CLI::Install.new(options).run
+    end
 
     def setup_cache_all
-      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+      all = options.fetch(:all, Bundler.feature_flag.cache_all? || nil)
 
-      if Bundler.definition.has_local_dependencies? && !Bundler.settings[: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."
-      end
+      Bundler.settings.set_command_option_if_given :cache_all, all
     end
   end
 end

data/lib/bundler/cli/check.rb

@@ -1,18 +1,19 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Check
     attr_reader :options
+
     def initialize(options)
       @options = options
     end
 
     def run
-      if options[:path]
-        Bundler.settings[:path] = File.expand_path(options[:path])
-        Bundler.settings[:disable_shared_gems] = "1"
-      end
+      Bundler.settings.set_command_option_if_given :path, options[:path]
+
       begin
         definition = Bundler.definition
-        definition.validate_ruby!
+        definition.validate_runtime!
         not_installed = definition.missing_specs
       rescue GemNotFound, VersionConflict
         Bundler.ui.error "Bundler can't satisfy your Gemfile's dependencies."
@@ -25,11 +26,11 @@ module Bundler
         not_installed.each {|s| Bundler.ui.error " * #{s.name} (#{s.version})" }
         Bundler.ui.warn "Install missing gems with `bundle install`"
         exit 1
-      elsif !Bundler.default_lockfile.exist? && Bundler.settings[:frozen]
+      elsif !Bundler.default_lockfile.file? && Bundler.frozen_bundle?
         Bundler.ui.error "This bundle has been frozen, but there is no #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} present"
         exit 1
       else
-        Bundler.load.lock(:preserve_bundled_with => true) unless options[:"dry-run"]
+        Bundler.load.lock(:preserve_unknown_sections => true) unless options[:"dry-run"]
         Bundler.ui.info "The Gemfile's dependencies are satisfied"
       end
     end

data/lib/bundler/cli/clean.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Clean
     attr_reader :options
@@ -7,19 +9,17 @@ module Bundler
     end
 
     def run
-      require_path_or_force
+      require_path_or_force unless options[:"dry-run"]
       Bundler.load.clean(options[:"dry-run"])
     end
 
-  protected
+    protected
 
     def require_path_or_force
-      if !Bundler.settings[:path] && !options[:force]
-        Bundler.ui.error "Cleaning all the gems on your system is dangerous! " \
-          "If you're sure you want to remove every system gem not in this " \
-          "bundle, run `bundle clean --force`."
-        exit 1
-      end
+      return unless Bundler.use_system_gems? && !options[:force]
+      raise InvalidOption, "Cleaning all the gems on your system is dangerous! " \
+        "If you're sure you want to remove every system gem not in this " \
+        "bundle, run `bundle clean --force`."
     end
   end
 end

data/lib/bundler/cli/common.rb

@@ -1,11 +1,45 @@
+# frozen_string_literal: true
+
 module Bundler
   module CLI::Common
-    def self.without_groups_message
-      groups = Bundler.settings.without
+    def self.output_post_install_messages(messages)
+      return if Bundler.settings["ignore_messages"]
+      messages.to_a.each do |name, msg|
+        print_post_install_message(name, msg) unless Bundler.settings["ignore_messages.#{name}"]
+      end
+    end
+
+    def self.print_post_install_message(name, msg)
+      Bundler.ui.confirm "Post-install message from #{name}:"
+      Bundler.ui.info msg
+    end
+
+    def self.output_fund_metadata_summary
+      definition = Bundler.definition
+      current_dependencies = definition.requested_dependencies
+      current_specs = definition.specs
+
+      count = current_dependencies.count {|dep| current_specs[dep.name].first.metadata.key?("funding_uri") }
+
+      return if count.zero?
+
+      intro = count > 1 ? "#{count} installed gems you directly depend on are" : "#{count} installed gem you directly depend on is"
+      message = "#{intro} looking for funding.\n  Run `bundle fund` for details"
+      Bundler.ui.info message
+    end
+
+    def self.output_without_groups_message(command)
+      return if Bundler.settings[:without].empty?
+      Bundler.ui.confirm without_groups_message(command)
+    end
+
+    def self.without_groups_message(command)
+      command_in_past_tense = command == :install ? "installed" : "updated"
+      groups = Bundler.settings[:without]
       group_list = [groups[0...-1].join(", "), groups[-1..-1]].
         reject {|s| s.to_s.empty? }.join(" and ")
-      group_str = (groups.size == 1) ? "group" : "groups"
-      "Gems in the #{group_str} #{group_list} were not installed."
+      group_str = groups.size == 1 ? "group" : "groups"
+      "Gems in the #{group_str} #{group_list} were not #{command_in_past_tense}."
     end
 
     def self.select_spec(name, regex_match = nil)
@@ -30,10 +64,6 @@ module Bundler
     end
 
     def self.ask_for_spec_from(specs)
-      if !$stdout.tty? && ENV["BUNDLE_SPEC_RUN"].nil?
-        raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
-      end
-
       specs.each_with_index do |spec, index|
         Bundler.ui.info "#{index.succ} : #{spec.name}", true
       end
@@ -44,12 +74,42 @@ module Bundler
     end
 
     def self.gem_not_found_message(missing_gem_name, alternatives)
-      require "bundler/similarity_detector"
+      require_relative "../similarity_detector"
       message = "Could not find gem '#{missing_gem_name}'."
       alternate_names = alternatives.map {|a| a.respond_to?(:name) ? a.name : a }
       suggestions = SimilarityDetector.new(alternate_names).similar_word_list(missing_gem_name)
       message += "\nDid you mean #{suggestions}?" if suggestions
       message
     end
+
+    def self.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems)
+      locked_names = locked_gems.specs.map(&:name).uniq
+      names.-(locked_names).each do |g|
+        raise GemNotFound, gem_not_found_message(g, locked_names)
+      end
+    end
+
+    def self.configure_gem_version_promoter(definition, options)
+      patch_level = patch_level_options(options)
+      patch_level << :patch if patch_level.empty? && Bundler.settings[:prefer_patch]
+      raise InvalidOption, "Provide only one of the following options: #{patch_level.join(", ")}" unless patch_level.length <= 1
+
+      definition.gem_version_promoter.tap do |gvp|
+        gvp.level = patch_level.first || :major
+        gvp.strict = options[:strict] || options["update-strict"] || options["filter-strict"]
+      end
+    end
+
+    def self.patch_level_options(options)
+      [:major, :minor, :patch].select {|v| options.keys.include?(v.to_s) }
+    end
+
+    def self.clean_after_install?
+      clean = Bundler.settings[:clean]
+      return clean unless clean.nil?
+      clean ||= Bundler.feature_flag.auto_clean_without_path? && Bundler.settings[:path].nil?
+      clean &&= !Bundler.use_system_gems?
+      clean
+    end
   end
 end

data/lib/bundler/cli/config.rb

@@ -1,100 +1,194 @@
+# frozen_string_literal: true
+
 module Bundler
-  class CLI::Config
-    attr_reader :name, :options, :scope, :thor
-    attr_accessor :args
-
-    def initialize(options, args, thor)
-      @options = options
-      @args = args
-      @thor = thor
-      @name = peek = args.shift
-      @scope = "global"
-      if peek && peek =~ /^\-\-/
-        @name = args.shift
-        @scope = $'
-      end
-    end
+  class CLI::Config < Thor
+    class_option :parseable, :type => :boolean, :banner => "Use minimal formatting for more parseable output"
 
-    def run
-      unless name
-        confirm_all
-        return
-      end
+    def self.scope_options
+      method_option :global, :type => :boolean, :banner => "Only change the global config"
+      method_option :local, :type => :boolean, :banner => "Only change the local config"
+    end
+    private_class_method :scope_options
 
-      unless valid_scope?(scope)
-        Bundler.ui.error "Invalid scope --#{scope} given. Please use --local or --global."
-        exit 1
-      end
+    desc "base NAME [VALUE]", "The Bundler 1 config interface", :hide => true
+    scope_options
+    method_option :delete, :type => :boolean, :banner => "delete"
+    def base(name = nil, *value)
+      new_args =
+        if ARGV.size == 1
+          ["config", "list"]
+        elsif ARGV.include?("--delete")
+          ARGV.map {|arg| arg == "--delete" ? "unset" : arg }
+        elsif ARGV.include?("--global") || ARGV.include?("--local") || ARGV.size == 3
+          ["config", "set", *ARGV[1..-1]]
+        else
+          ["config", "get", ARGV[1]]
+        end
 
-      if scope == "delete"
-        Bundler.settings.set_local(name, nil)
-        Bundler.settings.set_global(name, nil)
-        return
-      end
+      SharedHelpers.major_deprecation 3,
+        "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."
 
-      if args.empty?
-        confirm(name)
-        return
-      end
+      Base.new(options, name, value, self).run
+    end
 
-      Bundler.ui.info(message) if message
-      Bundler.settings.send("set_#{scope}", name, new_value)
+    desc "list", "List out all configured settings"
+    def list
+      Base.new(options, nil, nil, self).run
     end
 
-  private
+    desc "get NAME", "Returns the value for the given key"
+    def get(name)
+      Base.new(options, name, nil, self).run
+    end
 
-    def confirm_all
-      Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
-      Bundler.settings.all.each do |setting|
-        Bundler.ui.confirm "#{setting}"
-        show_pretty_values_for(setting)
-        Bundler.ui.confirm ""
-      end
+    desc "set NAME VALUE", "Sets the given value for the given key"
+    scope_options
+    def set(name, value, *value_)
+      Base.new(options, name, value_.unshift(value), self).run
     end
 
-    def confirm(name)
-      Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
-      show_pretty_values_for(name)
+    desc "unset NAME", "Unsets the value for the given key"
+    scope_options
+    def unset(name)
+      options[:delete] = true
+      Base.new(options, name, nil, self).run
     end
 
-    def new_value
-      pathname = Pathname.new(args.join(" "))
-      if name.match(/\Alocal\./) && pathname.directory?
-        pathname.expand_path.to_s
-      else
-        args.join(" ")
+    default_task :base
+
+    class Base
+      attr_reader :name, :value, :options, :scope, :thor
+
+      def initialize(options, name, value, thor)
+        @options = options
+        @name = name
+        value = Array(value)
+        @value = value.empty? ? nil : value.join(" ")
+        @thor = thor
+        validate_scope!
       end
-    end
 
-    def message
-      locations = Bundler.settings.locations(name)
-      if scope == "global"
-        if locations[:local]
-          "Your application has set #{name} to #{locations[:local].inspect}. " \
-            "This will override the global value you are currently setting"
-        elsif locations[:env]
-          "You have a bundler environment variable for #{name} set to " \
-            "#{locations[:env].inspect}. This will take precedence over the global value you are setting"
-        elsif locations[:global] && locations[:global] != args.join(" ")
-          "You are replacing the current global value of #{name}, which is currently " \
-            "#{locations[:global].inspect}"
+      def run
+        unless name
+          warn_unused_scope "Ignoring --#{scope}"
+          confirm_all
+          return
+        end
+
+        if options[:delete]
+          if !explicit_scope? || scope != "global"
+            Bundler.settings.set_local(name, nil)
+          end
+          if !explicit_scope? || scope != "local"
+            Bundler.settings.set_global(name, nil)
+          end
+          return
+        end
+
+        if value.nil?
+          warn_unused_scope "Ignoring --#{scope} since no value to set was given"
+
+          if options[:parseable]
+            if value = Bundler.settings[name]
+              Bundler.ui.info("#{name}=#{value}")
+            end
+            return
+          end
+
+          confirm(name)
+          return
         end
-      elsif scope == "local" && locations[:local] != args.join(" ")
-        "You are replacing the current local value of #{name}, which is currently " \
-          "#{locations[:local].inspect}"
+
+        Bundler.ui.info(message) if message
+        Bundler.settings.send("set_#{scope}", name, new_value)
       end
-    end
 
-    def show_pretty_values_for(setting)
-      thor.with_padding do
-        Bundler.settings.pretty_values_for(setting).each do |line|
-          Bundler.ui.info line
+      def confirm_all
+        if @options[:parseable]
+          thor.with_padding do
+            Bundler.settings.all.each do |setting|
+              val = Bundler.settings[setting]
+              Bundler.ui.info "#{setting}=#{val}"
+            end
+          end
+        else
+          Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
+          Bundler.settings.all.each do |setting|
+            Bundler.ui.confirm setting
+            show_pretty_values_for(setting)
+            Bundler.ui.confirm ""
+          end
+        end
+      end
+
+      def confirm(name)
+        Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
+        show_pretty_values_for(name)
+      end
+
+      def new_value
+        pathname = Pathname.new(value)
+        if name.start_with?("local.") && pathname.directory?
+          pathname.expand_path.to_s
+        else
+          value
+        end
+      end
+
+      def message
+        locations = Bundler.settings.locations(name)
+        if @options[:parseable]
+          "#{name}=#{new_value}" if new_value
+        elsif scope == "global"
+          if !locations[:local].nil?
+            "Your application has set #{name} to #{locations[:local].inspect}. " \
+              "This will override the global value you are currently setting"
+          elsif locations[:env]
+            "You have a bundler environment variable for #{name} set to " \
+              "#{locations[:env].inspect}. This will take precedence over the global value you are setting"
+          elsif !locations[:global].nil? && locations[:global] != value
+            "You are replacing the current global value of #{name}, which is currently " \
+              "#{locations[:global].inspect}"
+          end
+        elsif scope == "local" && !locations[:local].nil? && locations[:local] != value
+          "You are replacing the current local value of #{name}, which is currently " \
+            "#{locations[:local].inspect}"
         end
       end
-    end
 
-    def valid_scope?(scope)
-      %w(delete local global).include?(scope)
+      def show_pretty_values_for(setting)
+        thor.with_padding do
+          Bundler.settings.pretty_values_for(setting).each do |line|
+            Bundler.ui.info line
+          end
+        end
+      end
+
+      def explicit_scope?
+        @explicit_scope
+      end
+
+      def warn_unused_scope(msg)
+        return unless explicit_scope?
+        return if options[:parseable]
+
+        Bundler.ui.warn(msg)
+      end
+
+      def validate_scope!
+        @explicit_scope = true
+        scopes = %w[global local].select {|s| options[s] }
+        case scopes.size
+        when 0
+          @scope = "global"
+          @explicit_scope = false
+        when 1
+          @scope = scopes.first
+        else
+          raise InvalidOption,
+            "The options #{scopes.join " and "} were specified. Please only use one of the switches at a time."
+        end
+      end
     end
   end
 end