bundler 1.17.2 → 2.2.33

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 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."
+
+      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

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require "rbconfig"
+require "shellwords"
 
 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
 
@@ -22,14 +23,14 @@ module Bundler
     end
 
     def dylibs_darwin(path)
-      output = `/usr/bin/otool -L "#{path}"`.chomp
+      output = `/usr/bin/otool -L #{path.shellescape}`.chomp
       dylibs = output.split("\n")[1..-1].map {|l| l.match(DARWIN_REGEX).captures[0] }.uniq
       # ignore @rpath and friends
       dylibs.reject {|dylib| dylib.start_with? "@" }
     end
 
     def dylibs_ldd(path)
-      output = `/usr/bin/ldd "#{path}"`.chomp
+      output = `/usr/bin/ldd #{path.shellescape}`.chomp
       output.split("\n").map do |l|
         match = l.match(LDD_REGEX)
         next if match.nil?
@@ -56,12 +57,12 @@ module Bundler
     end
 
     def check!
-      require "bundler/cli/check"
+      require_relative "check"
       Bundler::CLI::Check.new({}).run
     end
 
     def run
-      Bundler.ui.level = "error" if options[:quiet]
+      Bundler.ui.level = "warn" if options[:quiet]
       Bundler.settings.validate!
       check!
 
@@ -93,15 +94,18 @@ module Bundler
       end
     end
 
-  private
+    private
 
     def check_home_permissions
       require "find"
       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|
-        if !File.writable?(f) || !File.readable?(f)
+      broken_symlinks = []
+      Find.find(Bundler.bundle_path.to_s).each do |f|
+        if !File.exist?(f)
+          broken_symlinks << f
+        elsif !File.writable?(f) || !File.readable?(f)
           if File.stat(f).uid != Process.uid
             files_not_rw_and_owned_by_different_user << f
           else
@@ -113,6 +117,13 @@ module Bundler
       end
 
       ok = true
+
+      if broken_symlinks.any?
+        Bundler.ui.warn "Broken links exist in the Bundler home. Please report them to the offending gem's upstream repo. These files are:\n - #{broken_symlinks.join("\n - ")}"
+
+        ok = false
+      end
+
       if files_not_owned_by_current_user_but_still_rw.any?
         Bundler.ui.warn "Files exist in the Bundler home that are owned by another " \
           "user, but are still readable/writable. These files are:\n - #{files_not_owned_by_current_user_but_still_rw.join("\n - ")}"

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
@@ -12,12 +12,7 @@ module Bundler
       @options = options
       @cmd = args.shift
       @args = args
-
-      if Bundler.current_ruby.ruby_2? && !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."
-      end
+      @args << { :close_others => !options.keep_file_descriptors? } unless Bundler.current_ruby.jruby?
     end
 
     def run
@@ -27,19 +22,14 @@ 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)
       end
     end
 
-  private
+    private
 
     def validate_cmd!
       return unless cmd.nil?
@@ -48,15 +38,11 @@ module Bundler
     end
 
     def kernel_exec(*args)
-      ui = Bundler.ui
-      Bundler.ui = nil
       Kernel.exec(*args)
     rescue Errno::EACCES, Errno::ENOEXEC
-      Bundler.ui = ui
       Bundler.ui.error "bundler: not executable: #{cmd}"
       exit 126
     rescue Errno::ENOENT
-      Bundler.ui = ui
       Bundler.ui.error "bundler: command not found: #{cmd}"
       Bundler.ui.warn "Install missing gem executables with `bundle install`"
       exit 127
@@ -67,18 +53,15 @@ module Bundler
       ARGV.replace(args)
       $0 = file
       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
       raise
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      Bundler.ui = ui
+    rescue Exception # rubocop:disable Lint/RescueException
       Bundler.ui.error "bundler: failed to load command: #{cmd} (#{file})"
-      backtrace = e.backtrace ? e.backtrace.take_while {|bt| !bt.start_with?(__FILE__) } : []
-      abort "#{e.class}: #{e.message}\n  #{backtrace.join("\n  ")}"
+      Bundler::FriendlyErrors.disable!
+      raise
     end
 
     def process_title(file, args)

data/lib/bundler/cli/fund.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Fund
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.definition.validate_runtime!
+
+      groups = Array(options[:group]).map(&:to_sym)
+
+      deps = if groups.any?
+        Bundler.definition.dependencies_for(groups)
+      else
+        Bundler.definition.current_dependencies
+      end
+
+      fund_info = deps.each_with_object([]) do |dep, arr|
+        spec = Bundler.definition.specs[dep.name].first
+        if spec.metadata.key?("funding_uri")
+          arr << "* #{spec.name} (#{spec.version})\n  Funding: #{spec.metadata["funding_uri"]}"
+        end
+      end
+
+      if fund_info.empty?
+        Bundler.ui.info "None of the installed gems you directly depend on are looking for funding."
+      else
+        Bundler.ui.info fund_info.join("\n")
+      end
+    end
+  end
+end