bundler 1.9.0 → 1.17.3

data/lib/bundler/cli/add.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Add
+    def initialize(options, gems)
+      @gems = gems
+      @options = options
+      @options[:group] = @options[:group].split(",").map(&:strip) if !@options[:group].nil? && !@options[:group].empty?
+    end
+
+    def run
+      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 = @options[:version].nil? ? nil : @options[:version].split(",").map(&:strip)
+
+      unless version.nil?
+        version.each do |v|
+          raise InvalidOption, "Invalid gem requirement pattern '#{v}'" unless Gem::Requirement::PATTERN =~ v.to_s
+        end
+      end
+
+      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])
+
+      Installer.install(Bundler.root, Bundler.definition) unless @options["skip-install"]
+    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,30 +9,41 @@ 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 }
+
+      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)
+          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
-
   end
 end

data/lib/bundler/cli/cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Cache
     attr_reader :options
@@ -6,12 +8,12 @@ module Bundler
     end
 
     def run
-      Bundler.definition.validate_ruby!
+      Bundler.definition.validate_runtime!
       Bundler.definition.resolve_with_cache!
       setup_cache_all
-      Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")
+      Bundler.settings.set_command_option_if_given :cache_all_platforms, options["all-platforms"]
       Bundler.load.cache
-      Bundler.settings[:no_prune] = true if options["no-prune"]
+      Bundler.settings.set_command_option_if_given :no_prune, options["no-prune"]
       Bundler.load.lock
     rescue GemNotFound => e
       Bundler.ui.error(e.message)
@@ -22,14 +24,13 @@ module Bundler
   private
 
     def setup_cache_all
-      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+      Bundler.settings.set_command_option_if_given :cache_all, options[: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."
       end
     end
-
   end
 end

data/lib/bundler/cli/check.rb

@@ -1,35 +1,38 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Check
     attr_reader :options
+
     def initialize(options)
       @options = options
     end
 
     def run
-      Bundler.settings[:path] = File.expand_path(options[:path]) if options[:path]
+      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."
-        Bundler.ui.warn  "Install missing gems with `bundle install`."
+        Bundler.ui.warn "Install missing gems with `bundle install`."
         exit 1
       end
 
       if not_installed.any?
         Bundler.ui.error "The following gems are missing"
-        not_installed.each { |s| Bundler.ui.error " * #{s.name} (#{s.version})" }
+        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]
-        Bundler.ui.error "This bundle has been frozen, but there is no Gemfile.lock present"
+      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 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
-
   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,20 +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
 
     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,9 +1,28 @@
+# frozen_string_literal: true
+
 module Bundler
   module CLI::Common
+    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_without_groups_message
+      return if Bundler.settings[:without].empty?
+      Bundler.ui.confirm without_groups_message
+    end
+
     def self.without_groups_message
-      groups = Bundler.settings.without
+      groups = Bundler.settings[:without]
       group_list = [groups[0...-1].join(", "), groups[-1..-1]].
-        reject{|s| s.to_s.empty? }.join(" and ")
+        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."
     end
@@ -30,27 +49,54 @@ module Bundler
     end
 
     def self.ask_for_spec_from(specs)
-      if !$stdout.tty? && ENV['BUNDLE_SPEC_RUN'].nil?
+      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
-      Bundler.ui.info '0 : - exit -', true
+      Bundler.ui.info "0 : - exit -", true
 
-      num = Bundler.ui.ask('> ').to_i
+      num = Bundler.ui.ask("> ").to_i
       num > 0 ? specs[num - 1] : nil
     end
 
     def self.gem_not_found_message(missing_gem_name, alternatives)
-      require 'bundler/similarity_detector'
+      require "bundler/similarity_detector"
       message = "Could not find gem '#{missing_gem_name}'."
-      alternate_names = alternatives.map { |a| a.respond_to?(:name) ? a.name : a }
+      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)
+      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)
+      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"]
+      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,84 +1,119 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Config
-    attr_reader :options, :thor
+    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"
+      return unless peek && peek.start_with?("--")
+      @name = args.shift
+      @scope = peek[2..-1]
     end
 
     def run
-      peek = args.shift
-
-      if peek && peek =~ /^\-\-/
-        name, scope = args.shift, $'
-      else
-        name, scope = peek, "global"
-      end
-
       unless name
-        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}"
-          thor.with_padding do
-            Bundler.settings.pretty_values_for(setting).each do |line|
-              Bundler.ui.info line
-            end
-          end
-          Bundler.ui.confirm ""
-        end
+        confirm_all
         return
       end
 
-      case scope
-      when "delete"
+      unless valid_scope?(scope)
+        Bundler.ui.error "Invalid scope --#{scope} given. Please use --local or --global."
+        exit 1
+      end
+
+      if scope == "delete"
         Bundler.settings.set_local(name, nil)
         Bundler.settings.set_global(name, nil)
-      when "local", "global"
-        if args.empty?
-          Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
-          thor.with_padding do
-            Bundler.settings.pretty_values_for(name).each { |line| Bundler.ui.info line }
+        return
+      end
+
+      if args.empty?
+        if options[:parseable]
+          if value = Bundler.settings[name]
+            Bundler.ui.info("#{name}=#{value}")
           end
           return
         end
 
-        locations = Bundler.settings.locations(name)
+        confirm(name)
+        return
+      end
 
-        if scope == "global"
-          if local = locations[:local]
-            Bundler.ui.info "Your application has set #{name} to #{local.inspect}. This will override the " \
-              "global value you are currently setting"
-          end
+      Bundler.ui.info(message) if message
+      Bundler.settings.send("set_#{scope}", name, new_value)
+    end
 
-          if env = locations[:env]
-            Bundler.ui.info "You have a bundler environment variable for #{name} set to #{env.inspect}. " \
-              "This will take precedence over the global value you are setting"
-          end
+  private
 
-          if global = locations[:global]
-            Bundler.ui.info "You are replacing the current global value of #{name}, which is currently #{global.inspect}"
+    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
-
-        if scope == "local" && local = locations[:local]
-          Bundler.ui.info "You are replacing the current local value of #{name}, which is currently #{local.inspect}"
+      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
 
-        if name.match(/\Alocal\./)
-          pathname = Pathname.new(args.join(" "))
-          self.args = [pathname.expand_path.to_s] if pathname.directory?
-        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
 
-        Bundler.settings.send("set_#{scope}", name, args.join(" "))
+    def new_value
+      pathname = Pathname.new(args.join(" "))
+      if name.start_with?("local.") && pathname.directory?
+        pathname.expand_path.to_s
       else
-        Bundler.ui.error "Invalid scope --#{scope} given. Please use --local or --global."
-        exit 1
+        args.join(" ")
+      end
+    end
+
+    def message
+      locations = Bundler.settings.locations(name)
+      if @options[:parseable]
+        "#{name}=#{new_value}" if new_value
+      elsif 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}"
+        end
+      elsif scope == "local" && locations[:local] != args.join(" ")
+        "You are replacing the current local value of #{name}, which is currently " \
+          "#{locations[:local].inspect}"
       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
+        end
+      end
+    end
+
+    def valid_scope?(scope)
+      %w[delete local global].include?(scope)
+    end
   end
 end