bundler-plus 4.0.15

data/lib/bundler/cli/cache.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Cache
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.ui.level = "warn" if options[:quiet]
+      Bundler.settings.set_command_option_if_given :cache_path, options["cache-path"]
+
+      install
+
+      Bundler.settings.temporary(cache_all_platforms: options["all-platforms"]) do
+        Bundler.load.cache
+      end
+    end
+
+    private
+
+    def install
+      require_relative "install"
+      options = self.options.dup
+      options["local"] = false if Bundler.settings[:cache_all_platforms]
+      options["no-cache"] = true
+      Bundler::CLI::Install.new(options).run
+    end
+  end
+end

data/lib/bundler/cli/check.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Check
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.settings.set_command_option_if_given :path, options[:path]
+
+      definition = Bundler.definition
+      definition.validate_runtime!
+
+      begin
+        definition.check!
+        not_installed = definition.missing_specs
+      rescue GemNotFound, GitError, SolveFailure
+        Bundler.ui.error "Bundler can't satisfy your Gemfile's dependencies."
+        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})" }
+        Bundler.ui.warn "Install missing gems with `bundle install`"
+        exit 1
+      elsif !Bundler.default_lockfile.file? && Bundler.frozen_bundle?
+        Bundler.ui.error "This bundle has been frozen, but there is no #{SharedHelpers.relative_lockfile_path} present"
+        exit 1
+      else
+        definition.lock(true) unless options[:"dry-run"]
+        Bundler.ui.info "The Gemfile's dependencies are satisfied"
+      end
+    end
+  end
+end

data/lib/bundler/cli/clean.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Clean
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      require_path_or_force unless options[:"dry-run"]
+      Bundler.load.clean(options[:"dry-run"])
+    end
+
+    protected
+
+    def require_path_or_force
+      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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Bundler
+  module CLI::Common
+    def self.validate_cooldown!(value)
+      return if value.nil?
+      return if value.is_a?(Integer) && value >= 0
+      raise InvalidOption, "Expected `--cooldown` to be a non-negative integer, got #{value.inspect}"
+    end
+
+    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
+      return if Bundler.settings["ignore_funding_requests"]
+      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]
+      "Gems in the #{verbalize_groups(groups)} were not #{command_in_past_tense}."
+    end
+
+    def self.verbalize_groups(groups)
+      groups.map! {|g| "'#{g}'" }
+      group_list = [groups[0...-1].join(", "), groups[-1..-1]].
+        reject {|s| s.to_s.empty? }.join(" and ")
+      group_str = groups.size == 1 ? "group" : "groups"
+      "#{group_str} #{group_list}"
+    end
+
+    def self.select_spec(name, regex_match = nil)
+      specs = []
+      regexp = Regexp.new(name) if regex_match
+
+      Bundler.definition.specs.each do |spec|
+        return spec if spec.name == name
+        specs << spec if regexp && spec.name.match?(regexp)
+      end
+
+      default_spec = default_gem_spec(name)
+      specs << default_spec if default_spec
+
+      case specs.count
+      when 0
+        dep_in_other_group = Bundler.definition.current_dependencies.find {|dep|dep.name == name }
+
+        if dep_in_other_group
+          raise GemNotFound, "Could not find gem '#{name}', because it's in the #{verbalize_groups(dep_in_other_group.groups)}, configured to be ignored."
+        else
+          raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+        end
+      when 1
+        specs.first
+      else
+        ask_for_spec_from(specs)
+      end
+    rescue RegexpError
+      raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+    end
+
+    def self.default_gem_spec(name)
+      gem_spec = Gem::Specification.find_all_by_name(name).last
+      gem_spec if gem_spec&.default_gem?
+    end
+
+    def self.ask_for_spec_from(specs)
+      specs.each_with_index do |spec, index|
+        Bundler.ui.info "#{index.succ} : #{spec.name}", true
+      end
+      Bundler.ui.info "0 : - exit -", true
+
+      num = Bundler.ui.ask("> ").to_i
+      num > 0 ? specs[num - 1] : nil
+    end
+
+    def self.gem_not_found_message(missing_gem_name, alternatives)
+      message = "Could not find gem '#{missing_gem_name}'."
+      alternate_names = alternatives.map {|a| a.respond_to?(:name) ? a.name : a }
+      if alternate_names.include?(missing_gem_name.downcase)
+        message += "\nDid you mean '#{missing_gem_name.downcase}'?"
+      elsif defined?(DidYouMean::SpellChecker)
+        suggestions = DidYouMean::SpellChecker.new(dictionary: alternate_names).correct(missing_gem_name)
+        message += "\nDid you mean #{word_list(suggestions)}?" unless suggestions.empty?
+      end
+      message
+    end
+
+    def self.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems)
+      return unless 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["filter-strict"]
+        gvp.pre = options[:pre]
+      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.bundler_5_mode? && Bundler.settings[:path].nil?
+      clean &&= !Bundler.use_system_gems?
+      clean
+    end
+
+    def self.word_list(words)
+      if words.empty?
+        return ""
+      end
+
+      words = words.map {|word| "'#{word}'" }
+
+      if words.length == 1
+        return words[0]
+      end
+
+      [words[0..-2].join(", "), words[-1]].join(" or ")
+    end
+  end
+end

data/lib/bundler/cli/config.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Bundler
+  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
+
+    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
+
+      message = "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."
+      SharedHelpers.feature_deprecated! message
+
+      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
+
+    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
+
+      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"
+          current_value = Bundler.settings[name]
+
+          if options[:parseable]
+            if value = Bundler.settings[name]
+              Bundler.ui.info("#{name}=#{value}")
+            end
+          else
+            confirm(name)
+          end
+
+          if current_value.nil?
+            exit 1
+          else
+            return
+          end
+        end
+
+        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|
+            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
+
+      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 = inside_app? ? "local" : "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
+
+      private
+
+      def inside_app?
+        Bundler.root
+        true
+      rescue GemfileNotFound
+        false
+      end
+    end
+  end
+end

data/lib/bundler/cli/console.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Console
+    attr_reader :options, :group
+    def initialize(options, group)
+      @options = options
+      @group = group
+    end
+
+    def run
+      group ? Bundler.require(:default, *group.split(" ").map!(&:to_sym)) : Bundler.require
+      ARGV.clear
+
+      console = get_console(Bundler.settings[:console] || "irb")
+      console.start
+    end
+
+    def get_console(name)
+      require name
+      get_constant(name)
+    rescue LoadError
+      if name == "irb"
+        if defined?(Gem::BUNDLED_GEMS) && Gem::BUNDLED_GEMS.respond_to?(:force_activate)
+          Gem::BUNDLED_GEMS.force_activate "irb"
+          require name
+          return get_constant(name)
+        end
+        Bundler.ui.error "#{name} is not available"
+        exit 1
+      else
+        Bundler.ui.error "Couldn't load console #{name}, falling back to irb"
+        name = "irb"
+        retry
+      end
+    end
+
+    def get_constant(name)
+      const_name = {
+        "pry" => :Pry,
+        "ripl" => :Ripl,
+        "irb" => :IRB,
+      }[name]
+      Object.const_get(const_name)
+    end
+  end
+end

data/lib/bundler/cli/doctor/diagnose.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "shellwords"
+
+module Bundler
+  class CLI::Doctor::Diagnose
+    DARWIN_REGEX = /\s+(.+) \(compatibility /
+    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def otool_available?
+      Bundler.which("otool")
+    end
+
+    def ldd_available?
+      Bundler.which("ldd")
+    end
+
+    def dylibs_darwin(path)
+      output = `/usr/bin/otool -L #{path.shellescape}`.chomp
+      dylibs = output.split("\n")[1..-1].filter_map {|l| l.match(DARWIN_REGEX)&.match(1) }.uniq
+      # ignore @rpath and friends
+      dylibs.reject {|dylib| dylib.start_with? "@" }
+    end
+
+    def dylibs_ldd(path)
+      output = `/usr/bin/ldd #{path.shellescape}`.chomp
+      output.split("\n").filter_map do |l|
+        match = l.match(LDD_REGEX)
+        next if match.nil?
+        match.captures[0]
+      end
+    end
+
+    def dylibs(path)
+      case RbConfig::CONFIG["host_os"]
+      when /darwin/
+        return [] unless otool_available?
+        dylibs_darwin(path)
+      when /(linux|solaris|bsd)/
+        return [] unless ldd_available?
+        dylibs_ldd(path)
+      else # Windows, etc.
+        Bundler.ui.warn("Dynamic library check not supported on this platform.")
+        []
+      end
+    end
+
+    def bundles_for_gem(spec)
+      Dir.glob("#{spec.full_gem_path}/**/*.bundle")
+    end
+
+    def lookup_with_fiddle(path)
+      require "fiddle"
+      Fiddle.dlopen(path)
+      false
+    rescue Fiddle::DLError
+      true
+    end
+
+    def check!
+      require_relative "../check"
+      Bundler::CLI::Check.new({}).run
+    end
+
+    def diagnose_ssl
+      require_relative "ssl"
+      Bundler::CLI::Doctor::SSL.new({}).run
+    end
+
+    def run
+      Bundler.ui.level = "warn" if options[:quiet]
+      Bundler.settings.validate!
+      check!
+      diagnose_ssl if options[:ssl]
+
+      definition = Bundler.definition
+      broken_links = {}
+
+      definition.specs.each do |spec|
+        bundles_for_gem(spec).each do |bundle|
+          bad_paths = dylibs(bundle).select do |f|
+            lookup_with_fiddle(f)
+          end
+          if bad_paths.any?
+            broken_links[spec] ||= []
+            broken_links[spec].concat(bad_paths)
+          end
+        end
+      end
+
+      permissions_valid = check_home_permissions
+
+      if broken_links.any?
+        message = "The following gems are missing OS dependencies:"
+        broken_links.flat_map do |spec, paths|
+          paths.uniq.map do |path|
+            "\n * #{spec.name}: #{path}"
+          end
+        end.sort.each {|m| message += m }
+        raise ProductionError, message
+      elsif permissions_valid
+        Bundler.ui.info "No issues found with the installed bundle"
+      end
+    end
+
+    private
+
+    def check_home_permissions
+      require "find"
+      files_not_readable = []
+      files_not_readable_and_owned_by_different_user = []
+      files_not_owned_by_current_user_but_still_readable = []
+      broken_symlinks = []
+      Find.find(Bundler.bundle_path.to_s).each do |f|
+        if !File.exist?(f)
+          broken_symlinks << f
+        elsif !File.readable?(f)
+          if File.stat(f).uid != Process.uid
+            files_not_readable_and_owned_by_different_user << f
+          else
+            files_not_readable << f
+          end
+        elsif File.stat(f).uid != Process.uid
+          files_not_owned_by_current_user_but_still_readable << f
+        end
+      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_readable.any?
+        Bundler.ui.warn "Files exist in the Bundler home that are owned by another " \
+          "user, but are still readable. These files are:\n - #{files_not_owned_by_current_user_but_still_readable.join("\n - ")}"
+
+        ok = false
+      end
+
+      if files_not_readable_and_owned_by_different_user.any?
+        Bundler.ui.warn "Files exist in the Bundler home that are owned by another " \
+          "user, and are not readable. These files are:\n - #{files_not_readable_and_owned_by_different_user.join("\n - ")}"
+
+        ok = false
+      end
+
+      if files_not_readable.any?
+        Bundler.ui.warn "Files exist in the Bundler home that are not " \
+          "readable by the current user. These files are:\n - #{files_not_readable.join("\n - ")}"
+
+        ok = false
+      end
+
+      ok
+    end
+  end
+end