bundler 1.17.0.pre.2 → 2.1.0.pre.2

data/lib/bundler/cli/add.rb

@@ -2,34 +2,45 @@
 
 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) if !@options[:group].nil? && !@options[:group].empty?
+      @options[:group] = options[:group].split(",").map(&:strip) unless options[:group].nil?
+      @version = options[:version].split(",").map(&:strip) unless options[:version].nil?
     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?
+      validate_options!
+      inject_dependencies
+      perform_bundle_install unless options["skip-install"]
+    end
 
-      version = @options[:version].nil? ? nil : @options[:version].split(",").map(&:strip)
+  private
 
-      unless version.nil?
-        version.each do |v|
-          raise InvalidOption, "Invalid gem requirement pattern '#{v}'" unless Gem::Requirement::PATTERN =~ v.to_s
-        end
-      end
+    def perform_bundle_install
+      Installer.install(Bundler.root, Bundler.definition)
+    end
 
-      dependencies = @gems.map {|g| Bundler::Dependency.new(g, version, @options) }
+    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])
+        :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]
 
-      Installer.install(Bundler.root, Bundler.definition) unless @options["skip-install"]
+      # 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/common.rb

@@ -14,17 +14,18 @@ module Bundler
       Bundler.ui.info msg
     end
 
-    def self.output_without_groups_message
+    def self.output_without_groups_message(command)
       return if Bundler.settings[:without].empty?
-      Bundler.ui.confirm without_groups_message
+      Bundler.ui.confirm without_groups_message(command)
     end
 
-    def self.without_groups_message
+    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)
@@ -49,10 +50,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
@@ -63,7 +60,7 @@ 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)
@@ -72,7 +69,7 @@ module Bundler
     end
 
     def self.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems)
-      locked_names = locked_gems.specs.map(&:name)
+      locked_names = locked_gems.specs.map(&:name).uniq
       names.-(locked_names).each do |g|
         raise GemNotFound, gem_not_found_message(g, locked_names)
       end
@@ -80,10 +77,12 @@ module Bundler
 
     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"]
+        gvp.strict = options[:strict] || options["update-strict"] || options["filter-strict"]
       end
     end
 

data/lib/bundler/cli/config.rb

@@ -1,119 +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"
-      return unless peek && peek.start_with?("--")
-      @name = args.shift
-      @scope = peek[2..-1]
+  class CLI::Config < Thor
+    class_option :parseable, :type => :boolean, :banner => "Use minimal formatting for more parseable output"
+
+    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
 
-    def run
-      unless name
-        confirm_all
-        return
-      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
 
-      unless valid_scope?(scope)
-        Bundler.ui.error "Invalid scope --#{scope} given. Please use --local or --global."
-        exit 1
-      end
+      SharedHelpers.major_deprecation 2,
+        "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."
+
+      Base.new(options, name, value, self).run
+    end
+
+    desc "list", "List out all configured settings"
+    def list
+      Base.new(options, nil, nil, self).run
+    end
+
+    desc "get NAME", "Returns the value for the given key"
+    def get(name)
+      Base.new(options, name, nil, self).run
+    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
 
-      if scope == "delete"
-        Bundler.settings.set_local(name, nil)
-        Bundler.settings.set_global(name, nil)
-        return
+    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
+
+    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
 
-      if args.empty?
-        if options[:parseable]
-          if value = Bundler.settings[name]
-            Bundler.ui.info("#{name}=#{value}")
+      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
 
-        confirm(name)
-        return
-      end
+        if value.nil?
+          warn_unused_scope "Ignoring --#{scope} since no value to set was given"
 
-      Bundler.ui.info(message) if message
-      Bundler.settings.send("set_#{scope}", name, new_value)
-    end
+          if options[:parseable]
+            if value = Bundler.settings[name]
+              Bundler.ui.info("#{name}=#{value}")
+            end
+            return
+          end
 
-  private
+          confirm(name)
+          return
+        end
 
-    def confirm_all
-      if @options[:parseable]
-        thor.with_padding do
+        Bundler.ui.info(message) if message
+        Bundler.settings.send("set_#{scope}", name, new_value)
+      end
+
+      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|
-            val = Bundler.settings[setting]
-            Bundler.ui.info "#{setting}=#{val}"
+            Bundler.ui.confirm setting
+            show_pretty_values_for(setting)
+            Bundler.ui.confirm ""
           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 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(args.join(" "))
-      if name.start_with?("local.") && pathname.directory?
-        pathname.expand_path.to_s
-      else
-        args.join(" ")
+      def new_value
+        pathname = Pathname.new(value)
+        if name.start_with?("local.") && pathname.directory?
+          pathname.expand_path.to_s
+        else
+          value
+        end
       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}"
+      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
-      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
+      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
-    end
 
-    def valid_scope?(scope)
-      %w[delete local global].include?(scope)
+      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

data/lib/bundler/cli/console.rb

@@ -12,7 +12,7 @@ module Bundler
       Bundler::SharedHelpers.major_deprecation 2, "bundle console will be replaced " \
                            "by `bin/console` generated by `bundle gem <name>`"
 
-      group ? Bundler.require(:default, *(group.split.map!(&:to_sym))) : Bundler.require
+      group ? Bundler.require(:default, *group.split.map!(&:to_sym)) : Bundler.require
       ARGV.clear
 
       console = get_console(Bundler.settings[:console] || "irb")

data/lib/bundler/cli/doctor.rb

@@ -4,8 +4,8 @@ require "rbconfig"
 
 module Bundler
   class CLI::Doctor
-    DARWIN_REGEX = /\s+(.+) \(compatibility /
-    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/
+    DARWIN_REGEX = /\s+(.+) \(compatibility /.freeze
+    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/.freeze
 
     attr_reader :options
 
@@ -56,7 +56,7 @@ module Bundler
     end
 
     def check!
-      require "bundler/cli/check"
+      require_relative "check"
       Bundler::CLI::Check.new({}).run
     end
 
@@ -100,7 +100,7 @@ module Bundler
       files_not_readable_or_writable = []
       files_not_rw_and_owned_by_different_user = []
       files_not_owned_by_current_user_but_still_rw = []
-      Find.find(Bundler.home.to_s).each do |f|
+      Find.find(Bundler.bundle_path.to_s).each do |f|
         if !File.writable?(f) || !File.readable?(f)
           if File.stat(f).uid != Process.uid
             files_not_rw_and_owned_by_different_user << f

data/lib/bundler/cli/exec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "bundler/current_ruby"
+require_relative "../current_ruby"
 
 module Bundler
   class CLI::Exec
@@ -13,7 +13,7 @@ module Bundler
       @cmd = args.shift
       @args = args
 
-      if Bundler.current_ruby.ruby_2? && !Bundler.current_ruby.jruby?
+      if !Bundler.current_ruby.jruby?
         @args << { :close_others => !options.keep_file_descriptors? }
       elsif options.keep_file_descriptors?
         Bundler.ui.warn "Ruby version #{RUBY_VERSION} defaults to keeping non-standard file descriptors on Kernel#exec."
@@ -27,12 +27,7 @@ module Bundler
         if !Bundler.settings[:disable_exec_load] && ruby_shebang?(bin_path)
           return kernel_load(bin_path, *args)
         end
-        # First, try to exec directly to something in PATH
-        if Bundler.current_ruby.jruby_18?
-          kernel_exec(bin_path, *args)
-        else
-          kernel_exec([bin_path, cmd], *args)
-        end
+        kernel_exec(bin_path, *args)
       else
         # exec using the given command
         kernel_exec(cmd, *args)
@@ -69,7 +64,7 @@ module Bundler
       Process.setproctitle(process_title(file, args)) if Process.respond_to?(:setproctitle)
       ui = Bundler.ui
       Bundler.ui = nil
-      require "bundler/setup"
+      require_relative "../setup"
       TRAPPED_SIGNALS.each {|s| trap(s, "DEFAULT") }
       Kernel.load(file)
     rescue SystemExit, SignalException