bundler 1.10.6 → 1.11.0.pre.1

data/lib/bundler/runtime.rb

@@ -5,7 +5,7 @@ module Bundler
     include SharedHelpers
 
     def setup(*groups)
-      groups.map! { |g| g.to_sym }
+      groups.map!(&:to_sym)
 
       # Has to happen first
       clean_load_path
@@ -21,7 +21,7 @@ module Bundler
           raise GemNotFound, "#{spec.full_name} is missing. Run `bundle` to get it."
         end
 
-        if activated_spec = Bundler.rubygems.loaded_specs(spec.name) and activated_spec.version != spec.version
+        if (activated_spec = Bundler.rubygems.loaded_specs(spec.name)) && activated_spec.version != spec.version
           e = Gem::LoadError.new "You have already activated #{activated_spec.name} #{activated_spec.version}, " \
                                  "but your Gemfile requires #{spec.name} #{spec.version}. Prepending " \
                                  "`bundle exec` to your command may solve this."
@@ -35,7 +35,7 @@ module Bundler
         end
 
         Bundler.rubygems.mark_loaded(spec)
-        load_paths = spec.load_paths.reject {|path| $LOAD_PATH.include?(path)}
+        load_paths = spec.load_paths.reject {|path| $LOAD_PATH.include?(path) }
         $LOAD_PATH.unshift(*load_paths)
       end
 
@@ -55,13 +55,13 @@ module Bundler
     ]
 
     def require(*groups)
-      groups.map! { |g| g.to_sym }
+      groups.map!(&:to_sym)
       groups = [:default] if groups.empty?
 
       @definition.dependencies.each do |dep|
         # Skip the dependency if it is not in any of the requested
         # groups
-        next unless ((dep.groups & groups).any? && dep.current_platform?)
+        next unless (dep.groups & groups).any? && dep.current_platform?
 
         required_file = nil
 
@@ -73,18 +73,24 @@ module Bundler
             # Allow `require: true` as an alias for `require: <name>`
             file = dep.name if file == true
             required_file = file
-            Kernel.require file
+            begin
+              Kernel.require file
+            rescue => e
+              raise e if e.is_a?(LoadError) # we handle this a little later
+              raise Bundler::GemRequireError.new e,
+                "There was an error while trying to load the gem '#{file}'."
+            end
           end
         rescue LoadError => e
-          REQUIRE_ERRORS.find { |r| r =~ e.message }
+          REQUIRE_ERRORS.find {|r| r =~ e.message }
           raise if dep.autorequire || $1 != required_file
 
-          if dep.autorequire.nil? && dep.name.include?('-')
+          if dep.autorequire.nil? && dep.name.include?("-")
             begin
-              namespaced_file = dep.name.gsub('-', '/')
+              namespaced_file = dep.name.tr("-", "/")
               Kernel.require namespaced_file
             rescue LoadError => e
-              REQUIRE_ERRORS.find { |r| r =~ e.message }
+              REQUIRE_ERRORS.find {|r| r =~ e.message }
               raise if $1 != namespaced_file
             end
           end
@@ -96,19 +102,21 @@ module Bundler
       if groups.empty?
         dependencies
       else
-        dependencies.select { |d| (groups & d.groups).any? }
+        dependencies.select {|d| (groups & d.groups).any? }
       end
     end
 
-    alias gems specs
+    alias_method :gems, :specs
 
     def cache(custom_path = nil)
       cache_path = Bundler.app_cache(custom_path)
-      FileUtils.mkdir_p(cache_path) unless File.exist?(cache_path)
+      SharedHelpers.filesystem_access(cache_path) do |p|
+        FileUtils.mkdir_p(p)
+      end unless File.exist?(cache_path)
 
       Bundler.ui.info "Updating files in #{Bundler.settings.app_cache_path}"
       specs.each do |spec|
-        next if spec.name == 'bundler'
+        next if spec.name == "bundler"
         spec.source.send(:fetch_gem, spec) if Bundler.settings[:cache_all_platforms] && spec.source.respond_to?(:fetch_gem, true)
         spec.source.cache(spec, custom_path) if spec.source.respond_to?(:cache)
       end
@@ -122,7 +130,9 @@ module Bundler
     end
 
     def prune_cache(cache_path)
-      FileUtils.mkdir_p(cache_path) unless File.exist?(cache_path)
+      SharedHelpers.filesystem_access(cache_path) do |p|
+        FileUtils.mkdir_p(p)
+      end unless File.exist?(cache_path)
       resolve = @definition.resolve
       prune_gem_cache(resolve, cache_path)
       prune_git_and_path_cache(resolve, cache_path)
@@ -159,51 +169,20 @@ module Bundler
       spec_gem_executables.flatten!
 
       stale_gem_bins       = gem_bins - spec_gem_executables
-      stale_git_dirs       = git_dirs - spec_git_paths
+      stale_git_dirs       = git_dirs - spec_git_paths - ["#{Gem.dir}/bundler/gems/extensions"]
       stale_git_cache_dirs = git_cache_dirs - spec_git_cache_dirs
       stale_gem_dirs       = gem_dirs - spec_gem_paths
       stale_gem_files      = gem_files - spec_cache_paths
       stale_gemspec_files  = gemspec_files - spec_gemspec_paths
 
-      output = stale_gem_dirs.collect do |gem_dir|
-        full_name = Pathname.new(gem_dir).basename.to_s
-
-        parts   = full_name.split('-')
-        name    = parts[0..-2].join('-')
-        version = parts.last
-        output  = "#{name} (#{version})"
-
-        if dry_run
-          Bundler.ui.info "Would have removed #{output}"
-        else
-          Bundler.ui.info "Removing #{output}"
-          FileUtils.rm_rf(gem_dir)
-        end
-
-        output
-      end + stale_git_dirs.collect do |gem_dir|
-        full_name = Pathname.new(gem_dir).basename.to_s
-
-        parts    = full_name.split('-')
-        name     = parts[0..-2].join('-')
-        revision = parts[-1]
-        output   = "#{name} (#{revision})"
-
-        if dry_run
-          Bundler.ui.info "Would have removed #{output}"
-        else
-          Bundler.ui.info "Removing #{output}"
-          FileUtils.rm_rf(gem_dir)
-        end
-
-        output
-      end
+      removed_stale_gem_dirs = stale_gem_dirs.collect {|dir| remove_dir(dir, dry_run) }
+      removed_stale_git_dirs = stale_git_dirs.collect {|dir| remove_dir(dir, dry_run) }
+      output = removed_stale_gem_dirs + removed_stale_git_dirs
 
       unless dry_run
-        stale_gem_bins.each { |bin| FileUtils.rm(bin) if File.exist?(bin) }
-        stale_gem_files.each { |file| FileUtils.rm(file) if File.exist?(file) }
-        stale_gemspec_files.each { |file| FileUtils.rm(file) if File.exist?(file) }
-        stale_git_cache_dirs.each { |dir| FileUtils.rm_rf(dir) if File.exist?(dir) }
+        stale_files = stale_gem_bins + stale_gem_files + stale_gemspec_files
+        stale_files.each {|file| FileUtils.rm(file) if File.exist?(file) }
+        stale_git_cache_dirs.each {|dir| FileUtils.rm_rf(dir) if File.exist?(dir) }
       end
 
       output
@@ -213,7 +192,7 @@ module Bundler
       begin
         ENV["BUNDLE_BIN_PATH"] = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
       rescue Gem::GemNotFoundException
-        ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../bin/bundle", __FILE__)
+        ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../exe/bundle", __FILE__)
       end
 
       # Set BUNDLE_GEMFILE
@@ -225,7 +204,7 @@ module Bundler
   private
 
     def prune_gem_cache(resolve, cache_path)
-      cached  = Dir["#{cache_path}/*.gem"]
+      cached = Dir["#{cache_path}/*.gem"]
 
       cached = cached.delete_if do |path|
         spec = Bundler.rubygems.spec_from_gem path
@@ -246,7 +225,7 @@ module Bundler
     end
 
     def prune_git_and_path_cache(resolve, cache_path)
-      cached  = Dir["#{cache_path}/*/.bundlecache"]
+      cached = Dir["#{cache_path}/*/.bundlecache"]
 
       cached = cached.delete_if do |path|
         name = File.basename(File.dirname(path))
@@ -270,20 +249,37 @@ module Bundler
 
     def setup_manpath
       # Store original MANPATH for restoration later in with_clean_env()
-      ENV['BUNDLE_ORIG_MANPATH'] = ENV['MANPATH']
+      ENV["BUNDLE_ORIG_MANPATH"] = ENV["MANPATH"]
 
       # Add man/ subdirectories from activated bundles to MANPATH for man(1)
       manuals = $LOAD_PATH.map do |path|
-        man_subdir = path.sub(/lib$/, 'man')
-        man_subdir unless Dir[man_subdir + '/man?/'].empty?
+        man_subdir = path.sub(/lib$/, "man")
+        man_subdir unless Dir[man_subdir + "/man?/"].empty?
       end.compact
 
       unless manuals.empty?
-        ENV['MANPATH'] = manuals.concat(
-          ENV['MANPATH'].to_s.split(File::PATH_SEPARATOR)
+        ENV["MANPATH"] = manuals.concat(
+          ENV["MANPATH"].to_s.split(File::PATH_SEPARATOR)
         ).uniq.join(File::PATH_SEPARATOR)
       end
     end
 
+    def remove_dir(dir, dry_run)
+      full_name = Pathname.new(dir).basename.to_s
+
+      parts    = full_name.split("-")
+      name     = parts[0..-2].join("-")
+      version  = parts.last
+      output   = "#{name} (#{version})"
+
+      if dry_run
+        Bundler.ui.info "Would have removed #{output}"
+      else
+        Bundler.ui.info "Removing #{output}"
+        FileUtils.rm_rf(dir)
+      end
+
+      output
+    end
   end
 end

data/lib/bundler/settings.rb

@@ -1,10 +1,10 @@
-require 'uri'
+require "uri"
 
 module Bundler
   class Settings
-    BOOL_KEYS = %w(frozen cache_all no_prune disable_local_branch_check ignore_messages gem.mit gem.coc).freeze
-    NUMBER_KEYS = %w(retry timeout redirect).freeze
-    DEFAULT_CONFIG = {:retry => 3, :timeout => 10, :redirect => 5}
+    BOOL_KEYS = %w(frozen cache_all no_prune disable_local_branch_check ignore_messages gem.mit gem.coc silence_root_warning).freeze
+    NUMBER_KEYS = %w(retry timeout redirect ssl_verify_mode).freeze
+    DEFAULT_CONFIG = { :retry => 3, :timeout => 10, :redirect => 5 }
 
     def initialize(root = nil)
       @root          = root
@@ -17,9 +17,11 @@ module Bundler
       value = (@local_config[key] || ENV[key] || @global_config[key] || DEFAULT_CONFIG[name])
 
       case
-      when !value.nil? && is_bool(name)
+      when value.nil?
+        nil
+      when is_bool(name) || value == "false"
         to_bool(value)
-      when !value.nil? && is_num(name)
+      when is_num(name)
         value.to_i
       else
         value
@@ -27,11 +29,11 @@ module Bundler
     end
 
     def []=(key, value)
-      local_config_file or raise GemfileNotFound, "Could not locate Gemfile"
+      local_config_file || raise(GemfileNotFound, "Could not locate Gemfile")
       set_key(key, value, @local_config, local_config_file)
     end
 
-    alias :set_local :[]=
+    alias_method :set_local, :[]=
 
     def delete(key)
       @local_config.delete(key_for(key))
@@ -42,21 +44,19 @@ module Bundler
     end
 
     def all
-      env_keys = ENV.keys.select { |k| k =~ /BUNDLE_.*/ }
+      env_keys = ENV.keys.select {|k| k =~ /BUNDLE_.*/ }
 
       keys = @global_config.keys | @local_config.keys | env_keys
 
       keys.map do |key|
-        key.sub(/^BUNDLE_/, '').gsub(/__/, ".").downcase
+        key.sub(/^BUNDLE_/, "").gsub(/__/, ".").downcase
       end
     end
 
     def local_overrides
       repos = {}
       all.each do |k|
-        if k =~ /^local\./
-          repos[$'] = self[k]
-        end
+        repos[$'] = self[k] if k =~ /^local\./
       end
       repos
     end
@@ -147,7 +147,7 @@ module Bundler
     end
 
     def ignore_config?
-      ENV['BUNDLE_IGNORE_CONFIG']
+      ENV["BUNDLE_IGNORE_CONFIG"]
     end
 
     def app_cache_path
@@ -159,10 +159,9 @@ module Bundler
     end
 
   private
+
     def key_for(key)
-      if key.is_a?(String) && /https?:/ =~ key
-        key = normalize_uri(key).to_s
-      end
+      key = normalize_uri(key).to_s if key.is_a?(String) && /https?:/ =~ key
       key = key.to_s.gsub(".", "__").upcase
       "BUNDLE_#{key}"
     end
@@ -184,7 +183,7 @@ module Bundler
     end
 
     def to_bool(value)
-      !(value.nil? || value == '' || value =~ /^(false|f|no|n|0)$/i || value == false)
+      !(value.nil? || value == "" || value =~ /^(false|f|no|n|0)$/i || value == false)
     end
 
     def is_num(value)
@@ -192,11 +191,11 @@ module Bundler
     end
 
     def get_array(key)
-      self[key] ? self[key].split(":").map { |w| w.to_sym } : []
+      self[key] ? self[key].split(":").map(&:to_sym) : []
     end
 
     def set_array(key, array)
-     self[key] = (array.empty? ? nil : array.join(":")) if array
+      self[key] = (array.empty? ? nil : array.join(":")) if array
     end
 
     def set_key(key, value, hash, file)
@@ -205,9 +204,11 @@ module Bundler
       unless hash[key] == value
         hash[key] = value
         hash.delete(key) if value.nil?
-        FileUtils.mkdir_p(file.dirname)
-        require 'bundler/psyched_yaml'
-        File.open(file, "w") { |f| f.puts YAML.dump(hash) }
+        SharedHelpers.filesystem_access(file) do |p|
+          FileUtils.mkdir_p(p.dirname)
+          require "bundler/psyched_yaml"
+          File.open(p, "w") {|f| f.puts YAML.dump(hash) }
+        end
       end
 
       value
@@ -226,6 +227,7 @@ module Bundler
       valid_file = config_file && config_file.exist? && !config_file.size.zero?
       if !ignore_config? && valid_file
         config_regex = /^(BUNDLE_.+): (['"]?)(.*(?:\n(?!BUNDLE).+)?)\2$/
+        raise PermissionError.new(config_file, :read) unless config_file.readable?
         config_pairs = config_file.read.scan(config_regex).map do |m|
           key, _, value = m
           [convert_to_backward_compatible_key(key), value.gsub(/\s+/, " ").tr('"', "'")]
@@ -237,7 +239,7 @@ module Bundler
     end
 
     def convert_to_backward_compatible_key(key)
-      key = "#{key}/" if key =~ /https?:/i && key !~ %r[/\Z]
+      key = "#{key}/" if key =~ /https?:/i && key !~ %r{/\Z}
       key = key.gsub(".", "__") if key.include?(".")
       key
     end
@@ -246,13 +248,12 @@ module Bundler
     # TODO: is this the correct place to validate mirror URIs?
     def normalize_uri(uri)
       uri = uri.to_s
-      uri = "#{uri}/" unless uri =~ %r[/\Z]
+      uri = "#{uri}/" unless uri =~ %r{/\Z}
       uri = URI(uri)
       unless uri.absolute?
         raise ArgumentError, "Gem sources must be absolute. You provided '#{uri}'."
       end
       uri
     end
-
   end
 end

data/lib/bundler/setup.rb

@@ -1,9 +1,9 @@
-require 'bundler/shared_helpers'
+require "bundler/shared_helpers"
 
 if Bundler::SharedHelpers.in_bundle?
-  require 'bundler'
+  require "bundler"
 
-  if STDOUT.tty? || ENV['BUNDLER_FORCE_TTY']
+  if STDOUT.tty? || ENV["BUNDLER_FORCE_TTY"]
     begin
       Bundler.setup
     rescue Bundler::BundlerError => e

data/lib/bundler/shared_helpers.rb

@@ -1,13 +1,13 @@
-require 'pathname'
-require 'rubygems'
+require "pathname"
+require "rubygems"
 
-require 'bundler/constants'
-require 'bundler/rubygems_integration'
-require 'bundler/current_ruby'
+require "bundler/constants"
+require "bundler/rubygems_integration"
+require "bundler/current_ruby"
 
 module Gem
   class Dependency
-    if !instance_methods.map { |m| m.to_s }.include?("requirement")
+    unless method_defined? :requirement
       def requirement
         version_requirements
       end
@@ -29,7 +29,7 @@ module Bundler
       gemfile = default_gemfile
 
       case gemfile.basename.to_s
-      when 'gems.rb' then Pathname.new(gemfile.sub(/.rb$/, '.locked'))
+      when "gems.rb" then Pathname.new(gemfile.sub(/.rb$/, ".locked"))
       else Pathname.new("#{gemfile}.lock")
       end
     end
@@ -56,12 +56,12 @@ module Bundler
 
     def pwd
       Bundler.rubygems.ext_lock.synchronize do
-        Dir.pwd
+        Pathname.pwd
       end
     end
 
     def with_clean_git_env(&block)
-      keys    = %w[GIT_DIR GIT_WORK_TREE]
+      keys    = %w(GIT_DIR GIT_WORK_TREE)
       old_env = keys.inject({}) do |h, k|
         h.update(k => ENV[k])
       end
@@ -81,30 +81,54 @@ module Bundler
 
       # Set RUBYOPT
       rubyopt = [ENV["RUBYOPT"]].compact
-      if rubyopt.empty? || rubyopt.first !~ /-rbundler\/setup/
-        rubyopt.unshift %|-rbundler/setup|
-        ENV["RUBYOPT"] = rubyopt.join(' ')
+      if rubyopt.empty? || rubyopt.first !~ %r{-rbundler/setup}
+        rubyopt.unshift %(-rbundler/setup)
+        ENV["RUBYOPT"] = rubyopt.join(" ")
       end
 
       # Set RUBYLIB
       rubylib = (ENV["RUBYLIB"] || "").split(File::PATH_SEPARATOR)
-      rubylib.unshift File.expand_path('../..', __FILE__)
+      rubylib.unshift File.expand_path("../..", __FILE__)
       ENV["RUBYLIB"] = rubylib.uniq.join(File::PATH_SEPARATOR)
     end
 
+    # Rescues permissions errors raised by file system operations
+    # (ie. Errno:EACCESS) and raises more friendly errors instead.
+    #
+    # @param path [String] the path that the action will be attempted to
+    # @param action [Symbol, #to_s] the type of operation that will be
+    #   performed. For example: :write, :read, :exec
+    #
+    # @yield path
+    #
+    # @raise [Bundler::PermissionError] if Errno:EACCES is raised in the
+    #   given block
+    #
+    # @example
+    #   filesystem_access("vendor/cache", :write) do
+    #     FileUtils.mkdir_p("vendor/cache")
+    #   end
+    #
+    # @see {Bundler::PermissionError}
+    def filesystem_access(path, action = :write)
+      yield path
+    rescue Errno::EACCES
+      raise PermissionError.new(path, action)
+    end
+
   private
 
     def find_gemfile
-      given = ENV['BUNDLE_GEMFILE']
+      given = ENV["BUNDLE_GEMFILE"]
       return given if given && !given.empty?
 
-      find_file('Gemfile', 'gems.rb')
+      find_file("Gemfile", "gems.rb")
     end
 
     def find_file(*names)
-      search_up(*names) {|filename|
+      search_up(*names) do |filename|
         return filename if File.file?(filename)
-      }
+      end
     end
 
     def find_directory(*names)
@@ -118,16 +142,17 @@ module Bundler
       current  = File.expand_path(SharedHelpers.pwd)
 
       until !File.directory?(current) || current == previous
-        if ENV['BUNDLE_SPEC_RUN']
+        if ENV["BUNDLE_SPEC_RUN"]
           # avoid stepping above the tmp directory when testing
-          return nil if File.file?(File.join(current, 'bundler.gemspec'))
+          return nil if File.file?(File.join(current, "bundler.gemspec"))
         end
 
         names.each do |name|
           filename = File.join(current, name)
           yield filename
         end
-        current, previous = File.expand_path("..", current), current
+        previous = current
+        current = File.expand_path("..", current)
       end
     end