bundler 1.13.0.rc.1 → 1.13.0.rc.2

data/lib/bundler/cli.rb

@@ -16,6 +16,10 @@ module Bundler
       Bundler::SharedHelpers.print_major_deprecations!
     end
 
+    def self.dispatch(*)
+      super {|i| i.send(:print_command) }
+    end
+
     def initialize(*args)
       super
       Bundler.reset!
@@ -31,6 +35,7 @@ module Bundler
       raise InvalidOption, e.message
     ensure
       self.options ||= {}
+      Bundler.settings.cli_flags_given = !options.empty?
       Bundler.ui = UI::Shell.new(options)
       Bundler.ui.level = "debug" if options["verbose"]
 
@@ -38,7 +43,8 @@ module Bundler
         Bundler.ui.warn(
           "The RUBYGEMS_GEMDEPS environment variable is set. This enables RubyGems' " \
           "experimental Gemfile mode, which may conflict with Bundler and cause unexpected errors. " \
-          "To remove this warning, unset RUBYGEMS_GEMDEPS.", :wrap => true)
+          "To remove this warning, unset RUBYGEMS_GEMDEPS.", :wrap => true
+        )
       end
     end
 
@@ -67,7 +73,8 @@ module Bundler
         bundle-package
         bundle-update
         bundle-platform
-        gemfile.5)
+        gemfile.5
+      )
 
       if manpages.include?(command)
         root = File.expand_path("../man", __FILE__)
@@ -208,6 +215,14 @@ module Bundler
       "Update ruby specified in Gemfile.lock"
     method_option "bundler", :type => :string, :lazy_default => "> 0.a", :banner =>
       "Update the locked version of bundler"
+    method_option "patch", :type => :boolean, :hide => true, :banner =>
+      "Prefer updating only to next patch version"
+    method_option "minor", :type => :boolean, :hide => true, :banner =>
+      "Prefer updating only to next minor version"
+    method_option "major", :type => :boolean, :hide => true, :banner =>
+      "Prefer updating to next major version (default)"
+    method_option "strict", :type => :boolean, :hide => true, :banner =>
+      "Do not allow any gem to be updated past latest --patch/--minor/--major"
     def update(*gems)
       require "bundler/cli/update"
       Update.new(options, gems).run
@@ -223,9 +238,11 @@ module Bundler
     method_option "outdated", :type => :boolean,
                               :banner => "Show verbose output including whether gems are outdated."
     def show(gem_name = nil)
+      Bundler::SharedHelpers.major_deprecation("use `bundle show` instead of `bundle list`") if ARGV[0] == "list"
       require "bundler/cli/show"
       Show.new(options, gem_name).run
     end
+    # TODO: 2.0 remove `bundle list`
     map %w(list) => "show"
 
     desc "binstubs GEM [OPTIONS]", "Install the binstubs of the listed gem"
@@ -340,6 +357,7 @@ module Bundler
 
     desc "console [GROUP]", "Opens an IRB session with the bundle pre-loaded"
     def console(group = nil)
+      # TODO: Remove for 2.0
       require "bundler/cli/console"
       Console.new(options, group).run
     end
@@ -419,6 +437,7 @@ module Bundler
 
     desc "inject GEM VERSION ...", "Add the named gem(s), with version requirements, to the resolved Gemfile"
     def inject(name, version, *gems)
+      SharedHelpers.major_deprecation "The `inject` command has been replaced by the `add` command"
       require "bundler/cli/inject"
       Inject.new(options, name, version, gems).run
     end
@@ -436,6 +455,8 @@ module Bundler
       "Fall back to using the single-file index of all gems"
     method_option "add-platform", :type => :array, :default => [], :banner =>
       "add a new platform to the lockfile"
+    method_option "remove-platform", :type => :array, :default => [], :banner =>
+      "remove a platform from the lockfile"
     def lock
       require "bundler/cli/lock"
       Lock.new(options).run
@@ -446,6 +467,21 @@ module Bundler
       Env.new.write($stdout)
     end
 
+    desc "doctor [OPTIONS]", "Checks the bundle for common problems"
+    long_desc <<-D
+      Doctor scans the OS dependencies of each of the gems requested in the Gemfile. If
+      missing dependencies are detected, Bundler prints them and exits status 1.
+      Otherwise, Bundler prints a success message and exits with a status of 0.
+    D
+    method_option "gemfile", :type => :string, :banner =>
+      "Use the specified gemfile instead of Gemfile"
+    method_option "quiet", :type => :boolean, :banner =>
+        "Only output warnings and errors."
+    def doctor
+      require "bundler/cli/doctor"
+      Doctor.new(options).run
+    end
+
     if Bundler.settings[:plugins]
       require "bundler/cli/plugin"
       desc "plugin SUBCOMMAND ...ARGS", "manage the bundler plugins"
@@ -467,10 +503,12 @@ module Bundler
         else
           args
         end
-      elsif command.nil?
-        abort("Could not find command \"#{args.join(" ")}\".")
-      else
+      elsif help_used
+        args = args.dup
+        args.delete_at(help_used)
         ["help", command || args].flatten.compact
+      else
+        args
       end
     end
 
@@ -495,5 +533,16 @@ module Bundler
         Bundler.reset!
       end
     end
+
+    def print_command
+      return unless ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"] || Bundler.ui.debug?
+      _, _, config = @_initializer
+      current_command = config[:current_command].name
+      return if %w(exec version check platform show help).include?(current_command)
+      command = ["bundle", current_command] + args
+      command << Thor::Options.to_switches(options)
+      command.reject!(&:empty?)
+      Bundler.ui.info "Running `#{command * " "}` with bundler #{Bundler::VERSION}"
+    end
   end
 end

data/lib/bundler/cli/binstubs.rb

@@ -21,10 +21,11 @@ module Bundler
       end
 
       gems.each do |gem_name|
-        spec = installer.specs.find {|s| s.name == gem_name }
+        spec = Bundler.definition.specs.find {|s| s.name == gem_name }
         unless spec
           raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(
-            gem_name, Bundler.definition.specs)
+            gem_name, Bundler.definition.specs
+          )
         end
 
         if spec.name == "bundler"

data/lib/bundler/cli/console.rb

@@ -8,6 +8,9 @@ module Bundler
     end
 
     def run
+      Bundler::SharedHelpers.major_deprecation "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
 

data/lib/bundler/cli/doctor.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Bundler
+  class CLI::Doctor
+    DARWIN_REGEX = /\s+(.+) \(compatibility /
+    LDD_REGEX = /\t\S+ => (\S+) \(\S+\)/
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def otool_available?
+      system("otool --version 2>&1 >#{Bundler::NULL}")
+    end
+
+    def ldd_available?
+      !system("ldd --help 2>&1 >#{Bundler::NULL}").nil?
+    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 run
+      Bundler.ui.level = "error" if options[:quiet]
+
+      broken_links = {}
+
+      begin
+        definition = Bundler.definition
+        definition.validate_ruby!
+        not_installed = definition.missing_specs
+        raise GemNotFound if not_installed.any?
+      rescue GemNotFound
+        Bundler.ui.warn "This bundle's gems must be installed to run this command."
+        Bundler.ui.warn "Install missing gems with `bundle install`."
+        exit 0
+      end
+
+      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
+
+      if broken_links.any?
+        Bundler.ui.error "The following gems are missing OS dependencies"
+        broken_links.each do |spec, paths|
+          paths.uniq.each do |path|
+            Bundler.ui.error " * #{spec.name}: #{path}"
+          end
+        end
+        exit 1
+      end
+    end
+  end
+end

data/lib/bundler/cli/exec.rb

@@ -5,6 +5,8 @@ module Bundler
   class CLI::Exec
     attr_reader :options, :args, :cmd
 
+    RESERVED_SIGNALS = %w(SEGV BUS ILL FPE VTALRM KILL STOP).freeze
+
     def initialize(options, args)
       @options = options
       @cmd = args.shift
@@ -21,9 +23,15 @@ module Bundler
       validate_cmd!
       SharedHelpers.set_bundle_environment
       if bin_path = Bundler.which(cmd)
-        return kernel_load(bin_path, *args) if ruby_shebang?(bin_path)
+        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
-        kernel_exec([bin_path, cmd], *args)
+        if Bundler.current_ruby.jruby_18?
+          kernel_exec(bin_path, *args)
+        else
+          kernel_exec([bin_path, cmd], *args)
+        end
       else
         # exec using the given command
         kernel_exec(cmd, *args)
@@ -57,9 +65,12 @@ module Bundler
       args.pop if args.last.is_a?(Hash)
       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"
+      signals = Signal.list.keys - RESERVED_SIGNALS
+      signals.each {|s| trap(s, "DEFAULT") }
       Kernel.load(file)
     rescue SystemExit
       raise
@@ -70,9 +81,14 @@ module Bundler
       abort "#{e.class}: #{e.message}\n  #{backtrace.join("\n  ")}"
     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",
         "#!#{Gem.ruby}\n",
       ]
       first_line = File.open(file, "rb") {|f| f.read(possibilities.map(&:size).max) }

data/lib/bundler/cli/gem.rb

@@ -126,7 +126,7 @@ module Bundler
 
       executables.each do |file|
         path = target.join(file)
-        executable = (path.stat.mode | 0111)
+        executable = (path.stat.mode | 0o111)
         path.chmod(executable)
       end
 

data/lib/bundler/cli/inject.rb

@@ -1,33 +1,51 @@
 # frozen_string_literal: true
 module Bundler
   class CLI::Inject
-    attr_reader :options, :name, :version, :gems
+    attr_reader :options, :name, :version, :group, :source, :gems
     def initialize(options, name, version, gems)
       @options = options
       @name = name
-      @version = version
+      @version = version || last_version_number
+      @group = options[:group]
+      @source = options[:source]
       @gems = gems
     end
 
     def run
       # The required arguments allow Thor to give useful feedback when the arguments
       # are incorrect. This adds those first two arguments onto the list as a whole.
-      gems.unshift(version).unshift(name)
+      gems.unshift(source).unshift(group).unshift(version).unshift(name)
 
       # Build an array of Dependency objects out of the arguments
       deps = []
-      gems.each_slice(2) do |gem_name, gem_version|
-        deps << Bundler::Dependency.new(gem_name, gem_version)
+      gems.each_slice(4) do |gem_name, gem_version, gem_group, gem_source|
+        ops = Gem::Requirement::OPS.map {|key, _val| key }
+        has_op = ops.any? {|op| gem_version.start_with? op }
+        gem_version = "~> #{gem_version}" unless has_op
+        deps << Bundler::Dependency.new(gem_name, gem_version, "group" => gem_group, "source" => gem_source)
       end
 
-      added = Injector.inject(deps)
+      added = Injector.inject(deps, options)
 
       if added.any?
         Bundler.ui.confirm "Added to Gemfile:"
         Bundler.ui.confirm added.map {|g| "  #{g}" }.join("\n")
       else
-        Bundler.ui.confirm "All injected gems were already present in the Gemfile"
+        Bundler.ui.confirm "All gems were already present in the Gemfile"
       end
     end
+
+  private
+
+    def last_version_number
+      definition = Bundler.definition(true)
+      definition.resolve_remotely!
+      specs = definition.index[name].sort_by(&:version)
+      unless options[:pre]
+        specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
+      end
+      spec = specs.last
+      spec.version.to_s
+    end
   end
 end

data/lib/bundler/cli/install.rb

@@ -11,6 +11,8 @@ module Bundler
 
       warn_if_root
 
+      warn_if_outdated
+
       [:with, :without].each do |option|
         if options[option]
           options[option] = options[option].join(":").tr(" ", ":").split(":")
@@ -53,6 +55,11 @@ module Bundler
 
       Bundler::Fetcher.disable_endpoint = options["full-index"]
 
+      if options["binstubs"]
+        Bundler::SharedHelpers.major_deprecation \
+          "the --binstubs option will be removed in favor of `bundle binstubs`"
+      end
+
       # rubygems plugins sometimes hook into the gem install process
       Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
 
@@ -61,7 +68,7 @@ module Bundler
       definition = Bundler.definition
       definition.validate_ruby!
 
-      Installer.install(Bundler.root, definition, options)
+      installer = Installer.install(Bundler.root, definition, options)
       Bundler.load.cache if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.settings[:frozen]
 
       Bundler.ui.confirm "Bundle complete! #{dependencies_count_for(definition)}, #{gems_installed_for(definition)}."
@@ -76,7 +83,7 @@ module Bundler
       end
 
       unless Bundler.settings["ignore_messages"]
-        Installer.post_install_messages.to_a.each do |name, msg|
+        installer.post_install_messages.to_a.each do |name, msg|
           print_post_install_message(name, msg) unless Bundler.settings["ignore_messages.#{name}"]
         end
       end
@@ -114,6 +121,20 @@ module Bundler
         "application for all non-root users on this machine.", :wrap => true
     end
 
+    def warn_if_outdated
+      return if ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"].nil?
+      installed_version = Gem::Version.new(ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"].dup)
+      running_version = Gem::Version.new(Bundler::VERSION)
+      return if Gem::Requirement.new(installed_version).satisfied_by?(running_version)
+      if Bundler.settings[:warned_version].nil? || running_version > Gem::Version.new(Bundler.settings[:warned_version])
+        Bundler.settings[:warned_version] = running_version
+        Bundler.ui.warn "You're running Bundler #{installed_version} but this " \
+          "project uses #{running_version}. To update, run `bundle update " \
+          "--bundler`. You won't see this message again unless you upgrade " \
+          "to a newer version of Bundler.", :wrap => true
+      end
+    end
+
     def confirm_without_groups
       return unless Bundler.settings.without.any?
       require "bundler/cli/common"

data/lib/bundler/cli/lock.rb

@@ -26,11 +26,23 @@ module Bundler
         definition = Bundler.definition(true)
       end
 
-      options["add-platform"].each do |platform|
-        platform = Gem::Platform.new(platform)
+      options["remove-platform"].each do |platform|
+        definition.remove_platform(platform)
+      end
+
+      options["add-platform"].each do |platform_string|
+        platform = Gem::Platform.new(platform_string)
+        if platform.to_a.compact == %w(unknown)
+          Bundler.ui.warn "The platform `#{platform_string}` is unknown to RubyGems " \
+            "and adding it will likely lead to resolution errors"
+        end
         definition.add_platform(platform)
       end
 
+      if definition.platforms.empty?
+        raise InvalidOption, "Removing all platforms from the bundle is not allowed"
+      end
+
       definition.resolve_remotely! unless options[:local]
 
       if print