rubygems-update 2.6.4 → 2.6.5

data/bundler/lib/bundler/cli/binstubs.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require "bundler/cli/common"
+
+module Bundler
+  class CLI::Binstubs
+    attr_reader :options, :gems
+    def initialize(options, gems)
+      @options = options
+      @gems = gems
+    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?
+      installer = Installer.new(Bundler.root, Bundler.definition)
+
+      if 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 }
+        unless spec
+          raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(
+            gem_name, Bundler.definition.specs)
+        end
+
+        if spec.name == "bundler"
+          Bundler.ui.warn "Sorry, Bundler can only be run via Rubygems."
+        elsif options[:standalone]
+          installer.generate_standalone_bundler_executable_stubs(spec)
+        else
+          installer.generate_bundler_executable_stubs(spec, :force => options[:force], :binstubs_cmd => true)
+        end
+      end
+    end
+  end
+end

data/bundler/lib/bundler/cli/cache.rb

@@ -0,0 +1,35 @@
+# 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!
+      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
+    end
+
+  private
+
+    def setup_cache_all
+      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+
+      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
+    end
+  end
+end

data/bundler/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
+      if options[:path]
+        Bundler.settings[:path] = File.expand_path(options[:path])
+        Bundler.settings[:disable_shared_gems] = true
+      end
+
+      begin
+        definition = Bundler.definition
+        definition.validate_ruby!
+        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`."
+        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.exist? && Bundler.settings[:frozen]
+        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_unknown_sections => true) unless options[:"dry-run"]
+        Bundler.ui.info "The Gemfile's dependencies are satisfied"
+      end
+    end
+  end
+end

data/bundler/lib/bundler/cli/clean.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Bundler
+  class CLI::Clean
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      require_path_or_force
+      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
+    end
+  end
+end

data/bundler/lib/bundler/cli/common.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module Bundler
+  module CLI::Common
+    def self.without_groups_message
+      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."
+    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 =~ regexp
+      end
+
+      case specs.count
+      when 0
+        raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+      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.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
+      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)
+      require "bundler/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
+  end
+end

data/bundler/lib/bundler/cli/config.rb

@@ -0,0 +1,100 @@
+# 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]
+    end
+
+    def run
+      unless name
+        confirm_all
+        return
+      end
+
+      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)
+        return
+      end
+
+      if args.empty?
+        confirm(name)
+        return
+      end
+
+      Bundler.ui.info(message) if message
+      Bundler.settings.send("set_#{scope}", name, new_value)
+    end
+
+  private
+
+    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
+    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(" ")
+      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}"
+        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

data/bundler/lib/bundler/cli/console.rb

@@ -0,0 +1,39 @@
+# 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
+      Bundler.ui.error "Couldn't load console #{name}, falling back to irb"
+      require "irb"
+      get_constant("irb")
+    end
+
+    def get_constant(name)
+      const_name = {
+        "pry"  => :Pry,
+        "ripl" => :Ripl,
+        "irb"  => :IRB,
+      }[name]
+      Object.const_get(const_name)
+    rescue NameError
+      Bundler.ui.error "Could not find constant #{const_name}"
+      exit 1
+    end
+  end
+end

data/bundler/lib/bundler/cli/exec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require "bundler/current_ruby"
+
+module Bundler
+  class CLI::Exec
+    attr_reader :options, :args, :cmd
+
+    def initialize(options, args)
+      @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
+    end
+
+    def run
+      validate_cmd!
+      SharedHelpers.set_bundle_environment
+      if bin_path = Bundler.which(cmd)
+        return kernel_load(bin_path, *args) if ruby_shebang?(bin_path)
+        # First, try to exec directly to something in PATH
+        kernel_exec([bin_path, cmd], *args)
+      else
+        # exec using the given command
+        kernel_exec(cmd, *args)
+      end
+    end
+
+  private
+
+    def validate_cmd!
+      return unless cmd.nil?
+      Bundler.ui.error "bundler: exec needs a command to run"
+      exit 128
+    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
+    end
+
+    def kernel_load(file, *args)
+      args.pop if args.last.is_a?(Hash)
+      ARGV.replace(args)
+      $0 = file
+      ui = Bundler.ui
+      Bundler.ui = nil
+      require "bundler/setup"
+      Kernel.load(file)
+    rescue SystemExit
+      raise
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      Bundler.ui = ui
+      Bundler.ui.error "bundler: failed to load command: #{cmd} (#{file})"
+      backtrace = e.backtrace.take_while {|bt| !bt.start_with?(__FILE__) }
+      abort "#{e.class}: #{e.message}\n  #{backtrace.join("\n  ")}"
+    end
+
+    def ruby_shebang?(file)
+      possibilities = [
+        "#!/usr/bin/env ruby\n",
+        "#!#{Gem.ruby}\n",
+      ]
+      first_line = File.open(file, "rb") {|f| f.read(possibilities.map(&:size).max) }
+      possibilities.any? {|shebang| first_line.start_with?(shebang) }
+    end
+  end
+end

data/bundler/lib/bundler/cli/gem.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+require "pathname"
+
+module Bundler
+  class CLI::Gem
+    TEST_FRAMEWORK_VERSIONS = {
+      "rspec" => "3.0",
+      "minitest" => "5.0"
+    }.freeze
+
+    attr_reader :options, :gem_name, :thor, :name, :target
+
+    def initialize(options, gem_name, thor)
+      @options = options
+      @gem_name = resolve_name(gem_name)
+      @thor = thor
+
+      @name = @gem_name
+      @target = SharedHelpers.pwd.join(gem_name)
+
+      validate_ext_name if options[:ext]
+    end
+
+    def run
+      Bundler.ui.confirm "Creating gem '#{name}'..."
+
+      underscored_name = name.tr("-", "_")
+      namespaced_path = name.tr("-", "/")
+      constant_name = name.gsub(/-[_-]*(?![_-]|$)/) { "::" }.gsub(/([_-]+|(::)|^)(.|$)/) { $2.to_s + $3.upcase }
+      constant_array = constant_name.split("::")
+
+      git_user_name = `git config user.name`.chomp
+      git_user_email = `git config user.email`.chomp
+
+      config = {
+        :name             => name,
+        :underscored_name => underscored_name,
+        :namespaced_path  => namespaced_path,
+        :makefile_path    => "#{underscored_name}/#{underscored_name}",
+        :constant_name    => constant_name,
+        :constant_array   => constant_array,
+        :author           => git_user_name.empty? ? "TODO: Write your name" : git_user_name,
+        :email            => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
+        :test             => options[:test],
+        :ext              => options[:ext],
+        :exe              => options[:exe],
+        :bundler_version  => bundler_dependency_version
+      }
+      ensure_safe_gem_name(name, constant_array)
+
+      templates = {
+        "Gemfile.tt" => "Gemfile",
+        "gitignore.tt" => ".gitignore",
+        "lib/newgem.rb.tt" => "lib/#{namespaced_path}.rb",
+        "lib/newgem/version.rb.tt" => "lib/#{namespaced_path}/version.rb",
+        "newgem.gemspec.tt" => "#{name}.gemspec",
+        "Rakefile.tt" => "Rakefile",
+        "README.md.tt" => "README.md",
+        "bin/console.tt" => "bin/console",
+        "bin/setup.tt" => "bin/setup"
+      }
+
+      executables = %w(
+        bin/console
+        bin/setup
+      )
+
+      if test_framework = ask_and_set_test_framework
+        config[:test] = test_framework
+        config[:test_framework_version] = TEST_FRAMEWORK_VERSIONS[test_framework]
+
+        templates.merge!(".travis.yml.tt" => ".travis.yml")
+
+        case test_framework
+        when "rspec"
+          templates.merge!(
+            "rspec.tt" => ".rspec",
+            "spec/spec_helper.rb.tt" => "spec/spec_helper.rb",
+            "spec/newgem_spec.rb.tt" => "spec/#{namespaced_path}_spec.rb"
+          )
+        when "minitest"
+          templates.merge!(
+            "test/test_helper.rb.tt" => "test/test_helper.rb",
+            "test/newgem_test.rb.tt" => "test/#{namespaced_path}_test.rb"
+          )
+        end
+      end
+
+      config[:test_task] = config[:test] == "minitest" ? "test" : "spec"
+
+      if ask_and_set(:mit, "Do you want to license your code permissively under the MIT license?",
+        "This means that any other developer or company will be legally allowed to use your code " \
+        "for free as long as they admit you created it. You can read more about the MIT license " \
+        "at http://choosealicense.com/licenses/mit.")
+        config[:mit] = true
+        Bundler.ui.info "MIT License enabled in config"
+        templates.merge!("LICENSE.txt.tt" => "LICENSE.txt")
+      end
+
+      if ask_and_set(:coc, "Do you want to include a code of conduct in gems you generate?",
+        "Codes of conduct can increase contributions to your project by contributors who " \
+        "prefer collaborative, safe spaces. You can read more about the code of conduct at " \
+        "contributor-covenant.org. Having a code of conduct means agreeing to the responsibility " \
+        "of enforcing it, so be sure that you are prepared to do that. Be sure that your email " \
+        "address is specified as a contact in the generated code of conduct so that people know " \
+        "who to contact in case of a violation. For suggestions about " \
+        "how to enforce codes of conduct, see http://bit.ly/coc-enforcement.")
+        config[:coc] = true
+        Bundler.ui.info "Code of conduct enabled in config"
+        templates.merge!("CODE_OF_CONDUCT.md.tt" => "CODE_OF_CONDUCT.md")
+      end
+
+      templates.merge!("exe/newgem.tt" => "exe/#{name}") if config[:exe]
+
+      if options[:ext]
+        templates.merge!(
+          "ext/newgem/extconf.rb.tt" => "ext/#{name}/extconf.rb",
+          "ext/newgem/newgem.h.tt" => "ext/#{name}/#{underscored_name}.h",
+          "ext/newgem/newgem.c.tt" => "ext/#{name}/#{underscored_name}.c"
+        )
+      end
+
+      templates.each do |src, dst|
+        thor.template("newgem/#{src}", target.join(dst), config)
+      end
+
+      executables.each do |file|
+        path = target.join(file)
+        executable = (path.stat.mode | 0111)
+        path.chmod(executable)
+      end
+
+      Bundler.ui.info "Initializing git repo in #{target}"
+      Dir.chdir(target) do
+        `git init`
+        `git add .`
+      end
+
+      # Open gemspec in editor
+      open_editor(options["edit"], target.join("#{name}.gemspec")) if options[:edit]
+    end
+
+  private
+
+    def resolve_name(name)
+      SharedHelpers.pwd.join(name).basename.to_s
+    end
+
+    def ask_and_set(key, header, message)
+      choice = options[key]
+      choice = Bundler.settings["gem.#{key}"] if choice.nil?
+
+      if choice.nil?
+        Bundler.ui.confirm header
+        choice = Bundler.ui.yes? "#{message} y/(n):"
+        Bundler.settings.set_global("gem.#{key}", choice)
+      end
+
+      choice
+    end
+
+    def validate_ext_name
+      return unless gem_name.index("-")
+
+      Bundler.ui.error "You have specified a gem name which does not conform to the \n" \
+                       "naming guidelines for C extensions. For more information, \n" \
+                       "see the 'Extension Naming' section at the following URL:\n" \
+                       "http://guides.rubygems.org/gems-with-extensions/\n"
+      exit 1
+    end
+
+    def ask_and_set_test_framework
+      test_framework = options[:test] || Bundler.settings["gem.test"]
+
+      if test_framework.nil?
+        Bundler.ui.confirm "Do you want to generate tests with your gem?"
+        result = Bundler.ui.ask "Type 'rspec' or 'minitest' to generate those test files now and " \
+          "in the future. rspec/minitest/(none):"
+        if result =~ /rspec|minitest/
+          test_framework = result
+        else
+          test_framework = false
+        end
+      end
+
+      if Bundler.settings["gem.test"].nil?
+        Bundler.settings.set_global("gem.test", test_framework)
+      end
+
+      test_framework
+    end
+
+    def bundler_dependency_version
+      v = Gem::Version.new(Bundler::VERSION)
+      req = v.segments[0..1]
+      req << "a" if v.prerelease?
+      req.join(".")
+    end
+
+    def ensure_safe_gem_name(name, constant_array)
+      if name =~ /^\d/
+        Bundler.ui.error "Invalid gem name #{name} Please give a name which does not start with numbers."
+        exit 1
+      elsif constant_array.inject(Object) {|c, s| (c.const_defined?(s) && c.const_get(s)) || break }
+        Bundler.ui.error "Invalid gem name #{name} constant #{constant_array.join("::")} is already in use. Please choose another gem name."
+        exit 1
+      end
+    end
+
+    def open_editor(editor, file)
+      thor.run(%(#{editor} "#{file}"))
+    end
+  end
+end