bundler 1.12.6 → 1.13.0.pre.1

data/bin/rubocop

@@ -10,7 +10,7 @@ bundler_spec.dependencies.each do |dep|
   gem dep.name, dep.requirement.to_s
 end
 
-gem "rubocop", "= 0.37.1"
+gem "rubocop", "= 0.39.0"
 
 Gem.finish_resolve if Gem.respond_to?(:finish_resolve)
 

data/bundler.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.name        = "bundler"
   s.version     = Bundler::VERSION
   s.licenses    = ["MIT"]
-  s.authors     = ["André Arko", "Terence Lee", "Carl Lerche", "Yehuda Katz"]
-  s.email       = ["andre.arko+terence.lee@gmail.com"]
+  s.authors     = ["André Arko", "Samuel Giddins"]
+  s.email       = ["team@bundler.io"]
   s.homepage    = "http://bundler.io"
   s.summary     = "The best way to manage your application's dependencies"
   s.description = "Bundler manages an application's dependencies through its entire life, across many machines, systematically and repeatably"

data/exe/bundle

@@ -4,6 +4,13 @@
 # Exit cleanly from an early interrupt
 Signal.trap("INT") { exit 1 }
 
+unless ENV["BUNDLE_DISABLE_POSTIT"]
+  update = "update".start_with?(ARGV.first || " ") && ARGV.find {|a| a.start_with?("--bundler") }
+  update &&= update =~ /--bundler(?:=(.+))?/ && $1 || "> 0.a"
+  ENV["BUNDLER_VERSION"] = update if update
+  require "bundler/postit_trampoline"
+end
+
 require "bundler"
 # Check if an older version of bundler is installed
 $LOAD_PATH.each do |path|

data/lib/bundler.rb

@@ -38,6 +38,7 @@ module Bundler
   autoload :MatchPlatform,          "bundler/match_platform"
   autoload :Mirror,                 "bundler/mirror"
   autoload :Mirrors,                "bundler/mirror"
+  autoload :Plugin,                 "bundler/plugin"
   autoload :RemoteSpecification,    "bundler/remote_specification"
   autoload :Resolver,               "bundler/resolver"
   autoload :Retry,                  "bundler/retry"
@@ -52,6 +53,7 @@ module Bundler
   autoload :SourceList,             "bundler/source_list"
   autoload :RubyGemsGemInstaller,   "bundler/rubygems_gem_installer"
   autoload :UI,                     "bundler/ui"
+  autoload :URICredentialsFilter,   "bundler/uri_credentials_filter"
 
   class << self
     attr_writer :bundle_path
@@ -85,7 +87,7 @@ module Bundler
     end
 
     def setup(*groups)
-      # Just return if all groups are already loaded
+      # Return if all groups are already loaded
       return @setup if defined?(@setup)
 
       definition.validate_ruby!
@@ -194,8 +196,7 @@ module Bundler
     end
 
     def settings
-      return @settings if defined?(@settings)
-      @settings = Settings.new(app_config_path)
+      @settings ||= Settings.new(app_config_path)
     rescue GemfileNotFound
       @settings = Settings.new(Pathname.new(".bundle").expand_path)
     end
@@ -378,6 +379,8 @@ module Bundler
     end
 
     def reset!
+      @root = nil
+      @settings = nil
       @definition = nil
     end
 

data/lib/bundler/capistrano.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 # Capistrano task for Bundler.
 #
-# Just add "require 'bundler/capistrano'" in your Capistrano deploy.rb, and
+# Add "require 'bundler/capistrano'" in your Capistrano deploy.rb, and
 # Bundler will be activated after each new deployment.
 require "bundler/deployment"
 require "capistrano/version"

data/lib/bundler/cli.rb

@@ -16,6 +16,7 @@ module Bundler
 
     def initialize(*args)
       super
+      Bundler.reset!
 
       custom_gemfile = options[:gemfile] || Bundler.settings[:gemfile]
       ENV["BUNDLE_GEMFILE"] = File.expand_path(custom_gemfile) if custom_gemfile && !custom_gemfile.empty?
@@ -82,6 +83,10 @@ module Bundler
     end
 
     def self.handle_no_command_error(command, has_namespace = $thor_runner)
+      if Bundler.settings[:plugins] && Bundler::Plugin.command?(command)
+        return Bundler::Plugin.exec_command(command, ARGV[1..-1])
+      end
+
       return super unless command_path = Bundler.which("bundler-#{command}")
 
       Kernel.exec(command_path, *ARGV[1..-1])
@@ -199,6 +204,8 @@ module Bundler
       "Force downloading every gem."
     method_option "ruby", :type => :boolean, :banner =>
       "Update ruby specified in Gemfile.lock"
+    method_option "bundler", :type => :string, :lazy_default => "> 0.a", :banner =>
+      "Update the locked version of bundler"
     def update(*gems)
       require "bundler/cli/update"
       Update.new(options, gems).run
@@ -229,6 +236,8 @@ module Bundler
       "Overwrite existing binstubs if they exist"
     method_option "path", :type => :string, :lazy_default => "bin", :banner =>
       "Binstub destination directory (default bin)"
+    method_option "standalone", :type => :array, :lazy_default => [], :banner =>
+      "Make binstubs that can work without the Bundler runtime"
     def binstubs(*gems)
       require "bundler/cli/binstubs"
       Binstubs.new(options, gems).run
@@ -259,7 +268,7 @@ module Bundler
 
     desc "cache [OPTIONS]", "Cache all the gems to vendor/cache", :hide => true
     method_option "all",  :type => :boolean, :banner => "Include all sources (including path and git)."
-    method_option "all-platforms", :type => :boolean, :banner => "Include gems for all platforms, not just the current one"
+    method_option "all-platforms", :type => :boolean, :banner => "Include gems for all platforms present in the lockfile, not only the current one"
     method_option "no-prune", :type => :boolean, :banner => "Don't remove stale gems from the cache."
     def cache
       require "bundler/cli/cache"
@@ -268,11 +277,11 @@ module Bundler
 
     desc "package [OPTIONS]", "Locks and then caches all of the gems into vendor/cache"
     method_option "all",  :type => :boolean, :banner => "Include all sources (including path and git)."
-    method_option "all-platforms", :type => :boolean, :banner => "Include gems for all platforms, not just the current one"
+    method_option "all-platforms", :type => :boolean, :banner => "Include gems for all platforms present in the lockfile, not only the current one"
     method_option "cache-path", :type => :string, :banner =>
       "Specify a different cache path than the default (vendor/cache)."
     method_option "gemfile", :type => :string, :banner => "Use the specified gemfile instead of Gemfile"
-    method_option "no-install", :type => :boolean, :banner => "Don't actually install the gems, just package."
+    method_option "no-install", :type => :boolean, :banner => "Don't install the gems, only the package."
     method_option "no-prune", :type => :boolean, :banner => "Don't remove stale gems from the cache."
     method_option "path", :type => :string, :banner =>
       "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine"
@@ -359,14 +368,14 @@ module Bundler
       Viz requires the ruby-graphviz gem (and its dependencies).
       The associated gems must also be installed via 'bundle install'.
     D
-    method_option :file, :type => :string, :default => "gem_graph", :aliases => "-f", :banner => "The name to use for the generated file. see format option"
-    method_option :format, :type => :string, :default => "png", :aliases => "-F", :banner => "This is output format option. Supported format is png, jpg, svg, dot ..."
-    method_option :requirements, :type => :boolean, :default => false, :aliases => "-r", :banner => "Set to show the version of each required dependency."
-    method_option :version, :type => :boolean, :default => false, :aliases => "-v", :banner => "Set to show each gem version."
-    method_option :without, :type => :array, :default => [], :banner => "Exclude gems that are part of the specified named group."
+    method_option :file, :type => :string, :default => "gem_graph", :aliases => "-f", :desc => "The name to use for the generated file. see format option"
+    method_option :format, :type => :string, :default => "png", :aliases => "-F", :desc => "This is output format option. Supported format is png, jpg, svg, dot ..."
+    method_option :requirements, :type => :boolean, :default => false, :aliases => "-R", :desc => "Set to show the version of each required dependency."
+    method_option :version, :type => :boolean, :default => false, :aliases => "-v", :desc => "Set to show each gem version."
+    method_option :without, :type => :array, :default => [], :aliases => "-W", :banner => "GROUP[ GROUP...]", :desc => "Exclude gems that are part of the specified named group."
     def viz
       require "bundler/cli/viz"
-      Viz.new(options).run
+      Viz.new(options.dup).run
     end
 
     desc "gem GEM [OPTIONS]", "Creates a skeleton for creating a rubygem"
@@ -390,7 +399,7 @@ module Bundler
 
     desc "clean [OPTIONS]", "Cleans up unused gems in your bundler directory"
     method_option "dry-run", :type => :boolean, :default => false, :banner =>
-      "Only print out changes, do not actually clean gems"
+      "Only print out changes, do not clean gems"
     method_option "force", :type => :boolean, :default => false, :banner =>
       "Forces clean even if --path is not set"
     def clean
@@ -423,6 +432,8 @@ module Bundler
       "the path the lockfile should be written to"
     method_option "full-index", :type => :boolean, :default => false, :banner =>
       "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"
     def lock
       require "bundler/cli/lock"
       Lock.new(options).run
@@ -433,6 +444,12 @@ module Bundler
       Env.new.write($stdout)
     end
 
+    if Bundler.settings[:plugins]
+      require "bundler/cli/plugin"
+      desc "plugin SUBCOMMAND ...ARGS", "manage the bundler plugins"
+      subcommand "plugin", Plugin
+    end
+
     # Reformat the arguments passed to bundle that include a --help flag
     # into the corresponding `bundle help #{command}` call
     def self.reformatted_help_args(args)

data/lib/bundler/cli/binstubs.rb

@@ -29,6 +29,8 @@ module Bundler
 
         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

data/lib/bundler/cli/exec.rb

@@ -25,7 +25,7 @@ module Bundler
         # First, try to exec directly to something in PATH
         kernel_exec([bin_path, cmd], *args)
       else
-        # Just exec using the given command
+        # exec using the given command
         kernel_exec(cmd, *args)
       end
     end

data/lib/bundler/cli/install.rb

@@ -17,46 +17,18 @@ module Bundler
         end
       end
 
-      if options[:without] && options[:with]
-        conflicting_groups = options[:without] & options[:with]
-        unless conflicting_groups.empty?
-          Bundler.ui.error "You can't list a group in both, --with and --without." \
-          "The offending groups are: #{conflicting_groups.join(", ")}."
-          exit 1
-        end
-      end
-
-      Bundler.settings.with    = [] if options[:with] && options[:with].empty?
-      Bundler.settings.without = [] if options[:without] && options[:without].empty?
-
-      with = options.fetch("with", [])
-      with |= Bundler.settings.with.map(&:to_s)
-      with -= options[:without] if options[:without]
+      check_for_group_conflicts
 
-      without = options.fetch("without", [])
-      without |= Bundler.settings.without.map(&:to_s)
-      without -= options[:with] if options[:with]
-
-      options[:with]    = with
-      options[:without] = without
+      normalize_groups
 
       ENV["RB_USER_INSTALL"] = "1" if Bundler::FREEBSD
 
-      # Just disable color in deployment mode
+      # Disable color in deployment mode
       Bundler.ui.shell = Thor::Shell::Basic.new if options[:deployment]
 
       check_for_options_conflicts
 
-      if options["trust-policy"]
-        unless Bundler.rubygems.security_policies.keys.include?(options["trust-policy"])
-          Bundler.ui.error "Rubygems doesn't know about trust policy '#{options["trust-policy"]}'. " \
-            "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
-          exit 1
-        end
-        Bundler.settings["trust-policy"] = options["trust-policy"]
-      else
-        Bundler.settings["trust-policy"] = nil if Bundler.settings["trust-policy"]
-      end
+      check_trust_policy
 
       if options[:deployment] || options[:frozen]
         unless Bundler.default_lockfile.exist?
@@ -77,25 +49,15 @@ module Bundler
         options[:system] = true
       end
 
-      Bundler.settings[:path]     = nil if options[:system]
-      Bundler.settings[:path]     = "vendor/bundle" if options[:deployment]
-      Bundler.settings[:path]     = options["path"] if options["path"]
-      Bundler.settings[:path] ||= "bundle" if options["standalone"]
-      Bundler.settings[:bin]      = options["binstubs"] if options["binstubs"]
-      Bundler.settings[:bin]      = nil if options["binstubs"] && options["binstubs"].empty?
-      Bundler.settings[:shebang]  = options["shebang"] if options["shebang"]
-      Bundler.settings[:jobs]     = options["jobs"] if options["jobs"]
-      Bundler.settings[:no_prune] = true if options["no-prune"]
-      Bundler.settings[:no_install] = true if options["no-install"]
-      Bundler.settings[:clean]    = options["clean"] if options["clean"]
-      Bundler.settings.without    = options[:without]
-      Bundler.settings.with       = options[:with]
+      normalize_settings
+
       Bundler::Fetcher.disable_endpoint = options["full-index"]
-      Bundler.settings[:disable_shared_gems] = Bundler.settings[:path] ? true : nil
 
       # rubygems plugins sometimes hook into the gem install process
       Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
 
+      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.settings[:plugins]
+
       definition = Bundler.definition
       definition.validate_ruby!
 
@@ -119,16 +81,7 @@ module Bundler
         end
       end
 
-      Installer.ambiguous_gems.to_a.each do |name, installed_from_uri, *also_found_in_uris|
-        Bundler.ui.error "Warning: the gem '#{name}' was found in multiple sources."
-        Bundler.ui.error "Installed from: #{installed_from_uri}"
-        Bundler.ui.error "Also found in:"
-        also_found_in_uris.each {|uri| Bundler.ui.error "  * #{uri}" }
-        Bundler.ui.error "You should add a source requirement to restrict this gem to your preferred source."
-        Bundler.ui.error "For example:"
-        Bundler.ui.error "    gem '#{name}', :source => '#{installed_from_uri}'"
-        Bundler.ui.error "Then uninstall the gem '#{name}' (or delete all bundled gems) and then install again."
-      end
+      warn_ambiguous_gems
 
       if Bundler.settings[:clean] && Bundler.settings[:path]
         require "bundler/cli/clean"
@@ -182,6 +135,17 @@ module Bundler
       Bundler.ui.info msg
     end
 
+    def check_for_group_conflicts
+      if options[:without] && options[:with]
+        conflicting_groups = options[:without] & options[:with]
+        unless conflicting_groups.empty?
+          Bundler.ui.error "You can't list a group in both, --with and --without." \
+          "The offending groups are: #{conflicting_groups.join(", ")}."
+          exit 1
+        end
+      end
+    end
+
     def check_for_options_conflicts
       if (options[:path] || options[:deployment]) && options[:system]
         error_message = String.new
@@ -190,5 +154,72 @@ module Bundler
         raise InvalidOption.new(error_message)
       end
     end
+
+    def check_trust_policy
+      if options["trust-policy"]
+        unless Bundler.rubygems.security_policies.keys.include?(options["trust-policy"])
+          Bundler.ui.error "Rubygems doesn't know about trust policy '#{options["trust-policy"]}'. " \
+            "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
+          exit 1
+        end
+        Bundler.settings["trust-policy"] = options["trust-policy"]
+      else
+        Bundler.settings["trust-policy"] = nil if Bundler.settings["trust-policy"]
+      end
+    end
+
+    def normalize_groups
+      Bundler.settings.with    = [] if options[:with] && options[:with].empty?
+      Bundler.settings.without = [] if options[:without] && options[:without].empty?
+
+      with = options.fetch("with", [])
+      with |= Bundler.settings.with.map(&:to_s)
+      with -= options[:without] if options[:without]
+
+      without = options.fetch("without", [])
+      without |= Bundler.settings.without.map(&:to_s)
+      without -= options[:with] if options[:with]
+
+      options[:with]    = with
+      options[:without] = without
+    end
+
+    def normalize_settings
+      Bundler.settings[:path]                = nil if options[:system]
+      Bundler.settings[:path]                = "vendor/bundle" if options[:deployment]
+      Bundler.settings[:path]                = options["path"] if options["path"]
+      Bundler.settings[:path]              ||= "bundle" if options["standalone"]
+
+      Bundler.settings[:bin]                 = options["binstubs"] if options["binstubs"]
+      Bundler.settings[:bin]                 = nil if options["binstubs"] && options["binstubs"].empty?
+
+      Bundler.settings[:shebang]             = options["shebang"] if options["shebang"]
+
+      Bundler.settings[:jobs]                = options["jobs"] if options["jobs"]
+
+      Bundler.settings[:no_prune]            = true if options["no-prune"]
+
+      Bundler.settings[:no_install]          = true if options["no-install"]
+
+      Bundler.settings[:clean]               = options["clean"] if options["clean"]
+
+      Bundler.settings.without               = options[:without]
+      Bundler.settings.with                  = options[:with]
+
+      Bundler.settings[:disable_shared_gems] = Bundler.settings[:path] ? true : nil
+    end
+
+    def warn_ambiguous_gems
+      Installer.ambiguous_gems.to_a.each do |name, installed_from_uri, *also_found_in_uris|
+        Bundler.ui.error "Warning: the gem '#{name}' was found in multiple sources."
+        Bundler.ui.error "Installed from: #{installed_from_uri}"
+        Bundler.ui.error "Also found in:"
+        also_found_in_uris.each {|uri| Bundler.ui.error "  * #{uri}" }
+        Bundler.ui.error "You should add a source requirement to restrict this gem to your preferred source."
+        Bundler.ui.error "For example:"
+        Bundler.ui.error "    gem '#{name}', :source => '#{installed_from_uri}'"
+        Bundler.ui.error "Then uninstall the gem '#{name}' (or delete all bundled gems) and then install again."
+      end
+    end
   end
 end

data/lib/bundler/cli/lock.rb

@@ -26,6 +26,11 @@ module Bundler
         definition = Bundler.definition(true)
       end
 
+      options["add-platform"].each do |platform|
+        platform = Gem::Platform.new(platform)
+        definition.add_platform(platform)
+      end
+
       definition.resolve_remotely! unless options[:local]
 
       if print

data/lib/bundler/cli/open.rb

@@ -16,7 +16,9 @@ module Bundler
       path = Bundler::CLI::Common.select_spec(name, :regex_match).full_gem_path
       Dir.chdir(path) do
         command = Shellwords.split(editor) + [path]
-        system(*command) || Bundler.ui.info("Could not run '#{command.join(" ")}'")
+        Bundler.with_clean_env do
+          system(*command)
+        end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
       end
     end
   end

data/lib/bundler/cli/outdated.rb

@@ -23,11 +23,11 @@ module Bundler
       current_dependencies = {}
       Bundler.ui.silence { Bundler.load.dependencies.each {|dep| current_dependencies[dep.name] = dep } }
 
-      if gems.empty? && sources.empty?
+      definition = if gems.empty? && sources.empty?
         # We're doing a full update
-        definition = Bundler.definition(true)
+        Bundler.definition(true)
       else
-        definition = Bundler.definition(:gems => gems, :sources => sources)
+        Bundler.definition(:gems => gems, :sources => sources)
       end
 
       definition_resolution = proc { options["local"] ? definition.resolve_with_cache! : definition.resolve_remotely! }
@@ -48,13 +48,13 @@ module Bundler
         dependency = current_dependencies[current_spec.name]
 
         if options["strict"]
-          active_spec = definition.specs.detect {|spec| spec.name == current_spec.name }
+          active_spec = definition.specs.detect {|spec| spec.name == current_spec.name && spec.platform == current_spec.platform }
         else
-          active_spec = definition.index[current_spec.name].sort_by(&:version)
-          if !current_spec.version.prerelease? && !options[:pre] && active_spec.size > 1
-            active_spec = active_spec.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
+          active_specs = definition.index[current_spec.name].select {|spec| spec.platform == current_spec.platform }.sort_by(&:version)
+          if !current_spec.version.prerelease? && !options[:pre] && active_specs.size > 1
+            active_spec = active_specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
           end
-          active_spec = active_spec.last
+          active_spec = active_specs.last
 
           if options[:major] || options[:minor] || options[:patch]
             update_present = update_present_via_semver_portions(current_spec, active_spec, options)