bundler 1.10.6 → 1.11.2

data/lib/bundler/rubygems_integration.rb

@@ -1,6 +1,6 @@
-require 'monitor'
-require 'rubygems'
-require 'rubygems/config_file'
+require "monitor"
+require "rubygems"
+require "rubygems/config_file"
 
 module Bundler
   class RubygemsIntegration
@@ -62,11 +62,15 @@ module Bundler
     end
 
     def configuration
+      require "bundler/psyched_yaml"
       Gem.configuration
     rescue Gem::SystemExitException => e
       Bundler.ui.error "#{e.class}: #{e.message}"
       Bundler.ui.trace e
-      raise Gem::SystemExitException
+      raise
+    rescue YamlLibrarySyntaxError => e
+      raise YamlSyntaxError.new(e, "Your RubyGems configuration, which is " \
+        "usually located in ~/.gemrc, contains invalid YAML syntax.")
     end
 
     def ruby_engine
@@ -111,14 +115,14 @@ module Bundler
     end
 
     def gem_cache
-      gem_path.map{|p| File.expand_path("cache", p) }
+      gem_path.map {|p| File.expand_path("cache", p) }
     end
 
     def spec_cache_dirs
       @spec_cache_dirs ||= begin
-        dirs = gem_path.map {|dir| File.join(dir, 'specifications')}
+        dirs = gem_path.map {|dir| File.join(dir, "specifications") }
         dirs << Gem.spec_cache_dir if Gem.respond_to?(:spec_cache_dir) # Not in Rubygems 2.0.3 or earlier
-        dirs.uniq.select {|dir| File.directory? dir}
+        dirs.uniq.select {|dir| File.directory? dir }
       end
     end
 
@@ -131,7 +135,7 @@ module Bundler
     end
 
     def repository_subdirectories
-      %w[cache doc gems specifications]
+      %w(cache doc gems specifications)
     end
 
     def clear_paths
@@ -151,11 +155,11 @@ module Bundler
       # RubyGems 2.2+ can put binary extension into dedicated folders,
       # therefore use RubyGems facilities to obtain their load paths.
       if Gem::Specification.method_defined? :full_require_paths
-        loaded_gem_paths = Gem.loaded_specs.map {|n, s| s.full_require_paths}
+        loaded_gem_paths = Gem.loaded_specs.map {|_, s| s.full_require_paths }
         loaded_gem_paths.flatten
       else
         $LOAD_PATH.select do |p|
-          Bundler.rubygems.gem_path.any?{|gp| p =~ /^#{Regexp.escape(gp)}/ }
+          Bundler.rubygems.gem_path.any? {|gp| p =~ /^#{Regexp.escape(gp)}/ }
         end
       end
     end
@@ -180,18 +184,26 @@ module Bundler
       [] # if we can't download them, there aren't any
     end
 
-    def fetch_all_remote_specs
+    # TODO: This is for older versions of Rubygems... should we support the
+    # X-Gemfile-Source header on these old versions?
+    # Maybe the newer implementation will work on older Rubygems?
+    # It seems difficult to keep this implementation and still send the header.
+    def fetch_all_remote_specs(remote)
+      old_sources = Bundler.rubygems.sources
+      Bundler.rubygems.sources = [remote.uri.to_s]
       # Fetch all specs, minus prerelease specs
       spec_list = fetch_specs(true, false)
       # Then fetch the prerelease specs
       fetch_prerelease_specs.each {|k, v| spec_list[k] += v }
 
-      return spec_list
+      spec_list
+    ensure
+      Bundler.rubygems.sources = old_sources
     end
 
     def with_build_args(args)
       ext_lock.synchronize do
-        old_args = self.build_args
+        old_args = build_args
         begin
           self.build_args = args
           yield
@@ -202,12 +214,12 @@ module Bundler
     end
 
     def gem_from_path(path, policy = nil)
-      require 'rubygems/format'
+      require "rubygems/format"
       Gem::Format.from_file_by_path(path, policy)
     end
 
     def spec_from_gem(path, policy = nil)
-      require 'rubygems/security'
+      require "rubygems/security"
       gem_from_path(path, security_policies[policy]).spec
     rescue Gem::Package::FormatError
       raise GemspecError, "Could not read gem at #{path}. It may be corrupted."
@@ -216,7 +228,7 @@ module Bundler
           e.message =~ /unknown trust policy|unsigned gem/i ||
           e.message =~ /couldn't verify (meta)?data signature/i
         raise SecurityError,
-          "The gem #{File.basename(path, '.gem')} can't be installed because " \
+          "The gem #{File.basename(path, ".gem")} can't be installed because " \
           "the security policy didn't allow it, with the message: #{e.message}"
       else
         raise e
@@ -224,12 +236,12 @@ module Bundler
     end
 
     def build(spec, skip_validation = false)
-      require 'rubygems/builder'
+      require "rubygems/builder"
       Gem::Builder.new(spec).build
     end
 
     def build_gem(gem_dir, spec)
-       build(spec)
+      build(spec)
     end
 
     def download_gem(spec, uri, path)
@@ -239,12 +251,12 @@ module Bundler
     end
 
     def security_policy_keys
-      %w{High Medium Low AlmostNo No}.map { |level| "#{level}Security" }
+      %w(High Medium Low AlmostNo No).map {|level| "#{level}Security" }
     end
 
     def security_policies
       @security_policies ||= begin
-        require 'rubygems/security'
+        require "rubygems/security"
         Gem::Security::Policies
       rescue LoadError, NameError
         {}
@@ -255,8 +267,8 @@ module Bundler
       # Disable rubygems' gem activation system
       ::Kernel.class_eval do
         if private_method_defined?(:gem_original_require)
-          alias rubygems_require require
-          alias require gem_original_require
+          alias_method :rubygems_require, :require
+          alias_method :require, :gem_original_require
         end
 
         undef gem
@@ -266,11 +278,11 @@ module Bundler
     def replace_gem(specs)
       reverse_rubygems_kernel_mixin
 
-      executables = specs.map { |s| s.executables }.flatten
+      executables = specs.map(&:executables).flatten
 
       ::Kernel.send(:define_method, :gem) do |dep, *reqs|
-        if executables.include? File.basename(caller.first.split(':').first)
-          return
+        if executables.include? File.basename(caller.first.split(":").first)
+          break
         end
         reqs.pop if reqs.last.is_a?(Hash)
 
@@ -278,7 +290,7 @@ module Bundler
           dep = Gem::Dependency.new(dep, reqs)
         end
 
-        spec = specs.find  { |s| s.name == dep.name }
+        spec = specs.find {|s| s.name == dep.name }
 
         if spec.nil?
 
@@ -330,27 +342,25 @@ module Bundler
     # under bundler. The new Gem.bin_path only considers gems in
     # +specs+
     def replace_bin_path(specs)
-      gem_class = (class << Gem ; self ; end)
+      gem_class = (class << Gem; self; end)
       redefine_method(gem_class, :bin_path) do |name, *args|
         exec_name = args.first
 
-        if exec_name == 'bundle'
-          return ENV['BUNDLE_BIN_PATH']
-        end
+        return ENV["BUNDLE_BIN_PATH"] if exec_name == "bundle"
 
         spec = nil
 
         if exec_name
-          spec = specs.find { |s| s.executables.include?(exec_name) }
-          spec or raise Gem::Exception, "can't find executable #{exec_name}"
+          spec = specs.find {|s| s.executables.include?(exec_name) }
+          raise(Gem::Exception, "can't find executable #{exec_name}") unless spec
           unless spec.name == name
             warn "Bundler is using a binstub that was created for a different gem.\n" \
               "This is deprecated, in future versions you may need to `bundle binstub #{name}` " \
               "to work around a system/bundle conflict."
           end
         else
-          spec = specs.find  { |s| s.name == name }
-          exec_name = spec.default_executable or raise Gem::Exception, "no default executable for #{spec.full_name}"
+          spec = specs.find {|s| s.name == name }
+          raise Gem::Exception, "no default executable for #{spec.full_name}" unless exec_name = spec.default_executable
         end
 
         gem_bin = File.join(spec.full_gem_path, spec.bindir, exec_name)
@@ -362,8 +372,8 @@ module Bundler
     # Because Bundler has a static view of what specs are available,
     # we don't #refresh, so stub it out.
     def replace_refresh
-      gem_class = (class << Gem ; self ; end)
-      redefine_method(gem_class, :refresh) { }
+      gem_class = (class << Gem; self; end)
+      redefine_method(gem_class, :refresh) {}
     end
 
     # Replace or hook into Rubygems to provide a bundlerized view
@@ -391,8 +401,8 @@ module Bundler
 
     # This backport fixes the marshaling of @segments.
     def backport_yaml_initialize
-      redefine_method(Gem::Version, :yaml_initialize) do |tag, map|
-        @version = map['version']
+      redefine_method(Gem::Version, :yaml_initialize) do |_, map|
+        @version = map["version"]
         @segments = nil
         @hash = nil
       end
@@ -446,7 +456,7 @@ module Bundler
 
       def stub_rubygems(specs)
         # Rubygems versions lower than 1.7 use SourceIndex#from_gems_in
-        source_index_class = (class << Gem::SourceIndex ; self ; end)
+        source_index_class = (class << Gem::SourceIndex; self; end)
         source_index_class.send(:define_method, :from_gems_in) do |*args|
           source_index = Gem::SourceIndex.new
           source_index.spec_dirs = *args
@@ -499,9 +509,9 @@ module Bundler
       def stub_rubygems(specs)
         Gem::Specification.all = specs
 
-        Gem.post_reset {
+        Gem.post_reset do
           Gem::Specification.all = specs
-        }
+        end
 
         stub_source_index(specs)
       end
@@ -521,7 +531,8 @@ module Bundler
       # you call Gem::Installer#install with an :install_dir set. We have to
       # change it back for our sudo mode to work.
       def preserve_paths
-        old_dir, old_path = gem_dir, gem_path
+        old_dir = gem_dir
+        old_path = gem_path
         yield
         Gem.use_paths(old_dir, old_path)
       end
@@ -532,7 +543,7 @@ module Bundler
       # Rubygems 1.8.20 and adds the skip_validation parameter, so that's
       # when we start passing it through.
       def build(spec, skip_validation = false)
-        require 'rubygems/builder'
+        require "rubygems/builder"
         Gem::Builder.new(spec).build(skip_validation)
       end
     end
@@ -555,48 +566,55 @@ module Bundler
         Gem::Specification.find_all_by_name name
       end
 
-      def fetch_specs(source, name)
+      def fetch_specs(source, remote, name)
         path = source + "#{name}.#{Gem.marshal_version}.gz"
-        string = Gem::RemoteFetcher.fetcher.fetch_path(path)
+        fetcher = gem_remote_fetcher
+        fetcher.headers = { "X-Gemfile-Source" => remote.original_uri.to_s } if remote.original_uri
+        string = fetcher.fetch_path(path)
         Bundler.load_marshal(string)
       rescue Gem::RemoteFetcher::FetchError => e
         # it's okay for prerelease to fail
         raise e unless name == "prerelease_specs"
       end
 
-      def fetch_all_remote_specs
+      def fetch_all_remote_specs(remote)
         # Since SpecFetcher now returns NameTuples, we just fetch directly
         # and unmarshal the array ourselves.
         hash = {}
 
-        Gem.sources.each do |source|
-          source = URI.parse(source.to_s) unless source.is_a?(URI)
-          hash[source] = fetch_specs(source, "specs")
+        source = remote.uri
+        source = URI.parse(source.to_s) unless source.is_a?(URI)
+        hash[source] = fetch_specs(source, remote, "specs")
 
-          pres = fetch_specs(source, "prerelease_specs")
-          hash[source].push(*pres) if pres && !pres.empty?
-        end
+        pres = fetch_specs(source, remote, "prerelease_specs")
+        hash[source].push(*pres) if pres && !pres.empty?
 
         hash
       end
 
       def download_gem(spec, uri, path)
-        require 'resolv'
         uri = Bundler.settings.mirror_for(uri)
-        proxy, dns = configuration[:http_proxy], Resolv::DNS.new
-        fetcher = Gem::RemoteFetcher.new(proxy, dns)
+        fetcher = gem_remote_fetcher
+        fetcher.headers = { "X-Gemfile-Source" => spec.remote.original_uri.to_s } if spec.remote.original_uri
         fetcher.download(spec, uri, path)
       end
 
+      def gem_remote_fetcher
+        require "resolv"
+        proxy = configuration[:http_proxy]
+        dns = Resolv::DNS.new
+        Bundler::GemRemoteFetcher.new(proxy, dns)
+      end
+
       def gem_from_path(path, policy = nil)
-        require 'rubygems/package'
+        require "rubygems/package"
         p = Gem::Package.new(path)
         p.security_policy = policy if policy
-        return p
+        p
       end
 
       def build(spec, skip_validation = false)
-        require 'rubygems/package'
+        require "rubygems/package"
         Gem::Package.build(spec, skip_validation)
       end
 
@@ -613,23 +631,21 @@ module Bundler
       end
 
       def all_specs
-        require 'bundler/remote_specification'
+        require "bundler/remote_specification"
         Gem::Specification.stubs.map do |stub|
           StubSpecification.from_stub(stub)
         end
       end
 
       def backport_ext_builder_monitor
-        require 'rubygems/ext'
+        require "rubygems/ext"
 
         Gem::Ext::Builder.class_eval do
-          if !const_defined?(:CHDIR_MONITOR)
+          unless const_defined?(:CHDIR_MONITOR)
             const_set(:CHDIR_MONITOR, EXT_LOCK)
           end
 
-          if const_defined?(:CHDIR_MUTEX)
-            remove_const(:CHDIR_MUTEX)
-          end
+          remove_const(:CHDIR_MUTEX) if const_defined?(:CHDIR_MUTEX)
           const_set(:CHDIR_MUTEX, const_get(:CHDIR_MONITOR))
         end
       end
@@ -646,22 +662,21 @@ module Bundler
         end
       end
     end
-
   end
 
   if RubygemsIntegration.provides?(">= 2.1.0")
     @rubygems = RubygemsIntegration::MoreFuture.new
   elsif RubygemsIntegration.provides?(">= 1.99.99")
     @rubygems = RubygemsIntegration::Future.new
-  elsif RubygemsIntegration.provides?('>= 1.8.20')
+  elsif RubygemsIntegration.provides?(">= 1.8.20")
     @rubygems = RubygemsIntegration::MoreModern.new
-  elsif RubygemsIntegration.provides?('>= 1.8.5')
+  elsif RubygemsIntegration.provides?(">= 1.8.5")
     @rubygems = RubygemsIntegration::Modern.new
-  elsif RubygemsIntegration.provides?('>= 1.8.0')
+  elsif RubygemsIntegration.provides?(">= 1.8.0")
     @rubygems = RubygemsIntegration::AlmostModern.new
-  elsif RubygemsIntegration.provides?('>= 1.7.0')
+  elsif RubygemsIntegration.provides?(">= 1.7.0")
     @rubygems = RubygemsIntegration::Transitional.new
-  elsif RubygemsIntegration.provides?('>= 1.4.0')
+  elsif RubygemsIntegration.provides?(">= 1.4.0")
     @rubygems = RubygemsIntegration::Legacy.new
   else # Rubygems 1.3.6 and 1.3.7
     @rubygems = RubygemsIntegration::Ancient.new

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,29 @@ 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}"
+
+      # Do not try to cache specification for the gem described by the .gemspec
+      root_gem_name = nil
+      if gemspec_cache_hash = Bundler.instance_variable_get(:@gemspec_cache)
+        gemspec = gemspec_cache_hash.values.first
+        root_gem_name = gemspec.name unless gemspec.nil?
+      end
       specs.each do |spec|
-        next if spec.name == 'bundler'
+        next if spec.name == "bundler"
+        next if File.exist?("#{root_gem_name}.gemspec") && spec.source.class == Bundler::Source::Path && root_gem_name && spec.name == root_gem_name
         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 +138,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 +177,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 +200,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 +212,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 +233,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 +257,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