bundler 1.11.1 → 2.2.6

data/lib/bundler/cli/console.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Console
     attr_reader :options, :group
@@ -7,7 +9,10 @@ module Bundler
     end
 
     def run
-      group ? Bundler.require(:default, *(group.split.map!(&:to_sym))) : Bundler.require
+      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
       ARGV.clear
 
       console = get_console(Bundler.settings[:console] || "irb")

data/lib/bundler/cli/doctor.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Bundler
+  class CLI::Doctor
+    DARWIN_REGEX = /\s+(.+) \(compatibility /.freeze
+    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/.freeze
+
+    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}"`.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.split("\n").map do |l|
+        match = l.match(LDD_REGEX)
+        next if match.nil?
+        match.captures[0]
+      end.compact
+    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 check!
+      require_relative "check"
+      Bundler::CLI::Check.new({}).run
+    end
+
+    def run
+      Bundler.ui.level = "error" if options[:quiet]
+      Bundler.settings.validate!
+      check!
+
+      definition = Bundler.definition
+      broken_links = {}
+
+      definition.specs.each do |spec|
+        bundles_for_gem(spec).each do |bundle|
+          bad_paths = dylibs(bundle).select {|f| !File.exist?(f) }
+          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.map do |spec, paths|
+          paths.uniq.map do |path|
+            "\n * #{spec.name}: #{path}"
+          end
+        end.flatten.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_or_writable = []
+      files_not_rw_and_owned_by_different_user = []
+      files_not_owned_by_current_user_but_still_rw = []
+      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
+          else
+            files_not_readable_or_writable << f
+          end
+        elsif File.stat(f).uid != Process.uid
+          files_not_owned_by_current_user_but_still_rw << f
+        end
+      end
+
+      ok = true
+      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 - ")}"
+
+        ok = false
+      end
+
+      if files_not_rw_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/writable. These files are:\n - #{files_not_rw_and_owned_by_different_user.join("\n - ")}"
+
+        ok = false
+      end
+
+      if files_not_readable_or_writable.any?
+        Bundler.ui.warn "Files exist in the Bundler home that are not " \
+          "readable/writable by the current user. These files are:\n - #{files_not_readable_or_writable.join("\n - ")}"
+
+        ok = false
+      end
+
+      ok
+    end
+  end
+end

data/lib/bundler/cli/exec.rb

@@ -1,15 +1,19 @@
-require "bundler/current_ruby"
+# frozen_string_literal: true
+
+require_relative "../current_ruby"
 
 module Bundler
   class CLI::Exec
     attr_reader :options, :args, :cmd
 
+    TRAPPED_SIGNALS = %w[INT].freeze
+
     def initialize(options, args)
       @options = options
       @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."
@@ -17,35 +21,73 @@ module Bundler
     end
 
     def run
-      ui = Bundler.ui
-      raise ArgumentError if cmd.nil?
-
-      # First, try to exec directly to something in PATH
+      validate_cmd!
       SharedHelpers.set_bundle_environment
-      bin_path = Bundler.which(@cmd)
-      if bin_path
-        Bundler.ui = nil
-        Kernel.exec(bin_path, *args)
+      if bin_path = Bundler.which(cmd)
+        if !Bundler.settings[:disable_exec_load] && ruby_shebang?(bin_path)
+          return kernel_load(bin_path, *args)
+        end
+        kernel_exec(bin_path, *args)
+      else
+        # exec using the given command
+        kernel_exec(cmd, *args)
       end
+    end
+
+    private
 
-      # If that didn't work, set up the whole bundle
-      Bundler.definition.validate_ruby!
-      Bundler.load.setup_environment
-      Bundler.ui = nil
-      Kernel.exec(@cmd, *args)
+    def validate_cmd!
+      return unless cmd.nil?
+      Bundler.ui.error "bundler: exec needs a command to run"
+      exit 128
+    end
+
+    def kernel_exec(*args)
+      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
-    rescue ArgumentError
-      Bundler.ui = ui
-      Bundler.ui.error "bundler: exec needs a command to run"
-      exit 128
+    end
+
+    def kernel_load(file, *args)
+      args.pop if args.last.is_a?(Hash)
+      ARGV.replace(args)
+      $0 = file
+      Process.setproctitle(process_title(file, args)) if Process.respond_to?(:setproctitle)
+      require_relative "../setup"
+      TRAPPED_SIGNALS.each {|s| trap(s, "DEFAULT") }
+      Kernel.load(file)
+    rescue SystemExit, SignalException
+      raise
+    rescue Exception # rubocop:disable Lint/RescueException
+      Bundler.ui.error "bundler: failed to load command: #{cmd} (#{file})"
+      Bundler::FriendlyErrors.disable!
+      raise
+    end
+
+    def process_title(file, args)
+      "#{file} #{args.join(" ")}".strip
+    end
+
+    def ruby_shebang?(file)
+      possibilities = [
+        "#!/usr/bin/env ruby\n",
+        "#!/usr/bin/env jruby\n",
+        "#!/usr/bin/env truffleruby\n",
+        "#!#{Gem.ruby}\n",
+      ]
+
+      if File.zero?(file)
+        Bundler.ui.warn "#{file} is empty"
+        return false
+      end
+
+      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/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

data/lib/bundler/cli/gem.rb

@@ -1,18 +1,29 @@
+# frozen_string_literal: true
+
 require "pathname"
 
 module Bundler
+  class CLI
+    Bundler.require_thor_actions
+    include Thor::Actions
+  end
+
   class CLI::Gem
     TEST_FRAMEWORK_VERSIONS = {
       "rspec" => "3.0",
-      "minitest" => "5.0"
-    }
+      "minitest" => "5.0",
+      "test-unit" => "3.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
+      thor.behavior = :invoke
+      thor.destination_root = nil
 
       @name = @gem_name
       @target = SharedHelpers.pwd.join(gem_name)
@@ -27,10 +38,12 @@ module Bundler
       namespaced_path = name.tr("-", "/")
       constant_name = name.gsub(/-[_-]*(?![_-]|$)/) { "::" }.gsub(/([_-]+|(::)|^)(.|$)/) { $2.to_s + $3.upcase }
       constant_array = constant_name.split("::")
-      test_task = options[:test] == "minitest" ? "test" : "spec"
 
-      git_user_name = `git config user.name`.chomp
-      git_user_email = `git config user.email`.chomp
+      git_installed = Bundler.git_present?
+
+      git_author_name = git_installed ? `git config user.name`.chomp : ""
+      github_username = git_installed ? `git config github.user`.chomp : ""
+      git_user_email = git_installed ? `git config user.email`.chomp : ""
 
       config = {
         :name             => name,
@@ -39,39 +52,39 @@ module Bundler
         :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,
+        :author           => git_author_name.empty? ? "TODO: Write your name" : git_author_name,
         :email            => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
         :test             => options[:test],
-        :test_task        => test_task,
         :ext              => options[:ext],
-        :bin              => options[:bin],
-        :bundler_version  => bundler_dependency_version
+        :exe              => options[:exe],
+        :bundler_version  => bundler_dependency_version,
+        :github_username  => github_username.empty? ? "[USERNAME]" : github_username,
+        :required_ruby_version => Gem.ruby_version < Gem::Version.new("2.4.a") ? "2.3.0" : "2.4.0",
       }
       ensure_safe_gem_name(name, constant_array)
 
       templates = {
-        "Gemfile.tt" => "Gemfile",
-        "gitignore.tt" => ".gitignore",
+        "#{Bundler.preferred_gemfile_name}.tt" => Bundler.preferred_gemfile_name,
         "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"
+        "bin/setup.tt" => "bin/setup",
       }
 
-      executables = %w(
+      executables = %w[
         bin/console
         bin/setup
-      )
+      ]
+
+      templates.merge!("gitignore.tt" => ".gitignore") if Bundler.git_present?
 
       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!(
@@ -79,18 +92,38 @@ module Bundler
             "spec/spec_helper.rb.tt" => "spec/spec_helper.rb",
             "spec/newgem_spec.rb.tt" => "spec/#{namespaced_path}_spec.rb"
           )
+          config[:test_task] = :spec
         when "minitest"
           templates.merge!(
-            "test/test_helper.rb.tt" => "test/test_helper.rb",
-            "test/newgem_test.rb.tt" => "test/#{namespaced_path}_test.rb"
+            "test/minitest/test_helper.rb.tt" => "test/test_helper.rb",
+            "test/minitest/newgem_test.rb.tt" => "test/#{namespaced_path}_test.rb"
+          )
+          config[:test_task] = :test
+        when "test-unit"
+          templates.merge!(
+            "test/test-unit/test_helper.rb.tt" => "test/test_helper.rb",
+            "test/test-unit/newgem_test.rb.tt" => "test/#{namespaced_path}_test.rb"
           )
+          config[:test_task] = :test
         end
       end
 
+      config[:ci] = ask_and_set_ci
+      case config[:ci]
+      when "github"
+        templates.merge!("github/workflows/main.yml.tt" => ".github/workflows/main.yml")
+      when "travis"
+        templates.merge!("travis.yml.tt" => ".travis.yml")
+      when "gitlab"
+        templates.merge!("gitlab-ci.yml.tt" => ".gitlab-ci.yml")
+      when "circle"
+        templates.merge!("circleci/config.yml.tt" => ".circleci/config.yml")
+      end
+
       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.")
+        "at https://choosealicense.com/licenses/mit.")
         config[:mit] = true
         Bundler.ui.info "MIT License enabled in config"
         templates.merge!("LICENSE.txt.tt" => "LICENSE.txt")
@@ -103,13 +136,24 @@ module Bundler
         "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.")
+        "how to enforce codes of conduct, see https://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 options[:bin]
+      if ask_and_set(:rubocop, "Do you want to add rubocop as a dependency for gems you generate?",
+        "RuboCop is a static code analyzer that has out-of-the-box rules for many " \
+        "of the guidelines in the community style guide. " \
+        "For more information, see the RuboCop docs (https://docs.rubocop.org/en/stable/) " \
+        "and the Ruby Style Guides (https://github.com/rubocop-hq/ruby-style-guide).")
+        config[:rubocop] = true
+        config[:rubocop_version] = Gem.ruby_version < Gem::Version.new("2.4.a") ? "0.81.0" : "1.7"
+        Bundler.ui.info "RuboCop enabled in config"
+        templates.merge!("rubocop.yml.tt" => ".rubocop.yml")
+      end
+
+      templates.merge!("exe/newgem.tt" => "exe/#{name}") if config[:exe]
 
       if options[:ext]
         templates.merge!(
@@ -120,28 +164,37 @@ module Bundler
       end
 
       templates.each do |src, dst|
-        thor.template("newgem/#{src}", target.join(dst), config)
+        destination = target.join(dst)
+        SharedHelpers.filesystem_access(destination) do
+          thor.template("newgem/#{src}", destination, config)
+        end
       end
 
       executables.each do |file|
-        path = target.join(file)
-        executable = (path.stat.mode | 0111)
-        path.chmod(executable)
+        SharedHelpers.filesystem_access(target.join(file)) do |path|
+          executable = (path.stat.mode | 0o111)
+          path.chmod(executable)
+        end
       end
 
-      Bundler.ui.info "Initializing git repo in #{target}"
-      Dir.chdir(target) do
-        `git init`
-        `git add .`
+      if Bundler.git_present? && options[:git]
+        Bundler.ui.info "Initializing git repo in #{target}"
+        Dir.chdir(target) do
+          `git init`
+          `git add .`
+        end
       end
 
-      if options[:edit]
-        # Open gemspec in editor
-        thor.run("#{options["edit"]} \"#{target.join("#{name}.gemspec")}\"")
-      end
+      # Open gemspec in editor
+      open_editor(options["edit"], target.join("#{name}.gemspec")) if options[:edit]
+
+      Bundler.ui.info "Gem '#{name}' was successfully created. " \
+        "For more information on making a RubyGem visit https://bundler.io/guides/creating_gem.html"
+    rescue Errno::EEXIST => e
+      raise GenericSystemCallError.new(e, "There was a conflict while creating the new gem.")
     end
 
-  private
+    private
 
     def resolve_name(name)
       SharedHelpers.pwd.join(name).basename.to_s
@@ -166,18 +219,19 @@ module Bundler
       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"
+                       "https://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?
+      if test_framework.to_s.empty?
         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/
+        Bundler.ui.info hint_text("test")
+
+        result = Bundler.ui.ask "Enter a test framework. rspec/minitest/test-unit/(none):"
+        if result =~ /rspec|minitest|test-unit/
           test_framework = result
         else
           test_framework = false
@@ -188,9 +242,54 @@ module Bundler
         Bundler.settings.set_global("gem.test", test_framework)
       end
 
+      if options[:test] == Bundler.settings["gem.test"]
+        Bundler.ui.info "#{options[:test]} is already configured, ignoring --test flag."
+      end
+
       test_framework
     end
 
+    def hint_text(setting)
+      if Bundler.settings["gem.#{setting}"] == false
+        "Your choice will only be applied to this gem."
+      else
+        "Future `bundle gem` calls will use your choice. " \
+        "This setting can be changed anytime with `bundle config gem.#{setting}`."
+      end
+    end
+
+    def ask_and_set_ci
+      ci_template = options[:ci] || Bundler.settings["gem.ci"]
+
+      if ci_template.to_s.empty?
+        Bundler.ui.confirm "Do you want to set up continuous integration for your gem? " \
+          "Supported services:\n" \
+          "* CircleCI:       https://circleci.com/\n" \
+          "* GitHub Actions: https://github.com/features/actions\n" \
+          "* GitLab CI:      https://docs.gitlab.com/ee/ci/\n" \
+          "* Travis CI:      https://travis-ci.org/\n" \
+          "\n"
+        Bundler.ui.info hint_text("ci")
+
+        result = Bundler.ui.ask "Enter a CI service. github/travis/gitlab/circle/(none):"
+        if result =~ /github|travis|gitlab|circle/
+          ci_template = result
+        else
+          ci_template = false
+        end
+      end
+
+      if Bundler.settings["gem.ci"].nil?
+        Bundler.settings.set_global("gem.ci", ci_template)
+      end
+
+      if options[:ci] == Bundler.settings["gem.ci"]
+        Bundler.ui.info "#{options[:ci]} is already configured, ignoring --ci flag."
+      end
+
+      ci_template
+    end
+
     def bundler_dependency_version
       v = Gem::Version.new(Bundler::VERSION)
       req = v.segments[0..1]
@@ -202,10 +301,27 @@ module Bundler
       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
+
+      constant_name = constant_array.join("::")
+
+      existing_constant = constant_array.inject(Object) do |c, s|
+        defined = begin
+          c.const_defined?(s)
+        rescue NameError
+          Bundler.ui.error "Invalid gem name #{name} -- `#{constant_name}` is an invalid constant name"
+          exit 1
+        end
+        (defined && c.const_get(s)) || break
+      end
+
+      return unless existing_constant
+      Bundler.ui.error "Invalid gem name #{name} constant #{constant_name} is already in use. Please choose another gem name."
+      exit 1
+    end
+
+    def open_editor(editor, file)
+      thor.run(%(#{editor} "#{file}"))
     end
   end
 end