bundler 1.7.15 → 1.8.0.pre

data/lib/bundler/settings.rb

@@ -1,5 +1,7 @@
 module Bundler
   class Settings
+    BOOL_KEYS = %w(frozen cache_all no_prune disable_local_branch_check gem.mit gem.coc).freeze
+
     def initialize(root = nil)
       @root          = root
       @local_config  = load_config(local_config_file)
@@ -115,14 +117,22 @@ module Bundler
       ENV['BUNDLE_IGNORE_CONFIG']
     end
 
+    def app_cache_path
+      @app_cache_path ||= begin
+        path = self[:cache_path] || "vendor/cache"
+        raise InvalidOption, "Cache path must be relative to the bundle path" if path.start_with?("/")
+        path
+      end
+    end
+
   private
     def key_for(key)
-      key = key.to_s.sub(".", "__").upcase
+      key = key.to_s.gsub(".", "__").upcase
       "BUNDLE_#{key}"
     end
 
     def is_bool(key)
-      %w(frozen cache_all no_prune disable_local_branch_check).include? key.to_s
+      BOOL_KEYS.include?(key.to_s)
     end
 
     def to_bool(value)
@@ -155,10 +165,9 @@ module Bundler
     def load_config(config_file)
       valid_file = config_file && config_file.exist? && !config_file.size.zero?
       if !ignore_config? && valid_file
-        config_regex = /^(BUNDLE_.+): (['"]?)(.*(?:\n(?!BUNDLE).+)?)\2$/
+        config_regex = /^(BUNDLE_.+): (?:['"](.*)['"]|(.+(?:\n(?!BUNDLE).+))|(.+))$/
         config_pairs = config_file.read.scan(config_regex).map do |m|
-          key, _, value = m
-          [key, value.gsub(/\s+/, " ").tr('"', "'")]
+          m.compact.map { |n| n.gsub(/\s+/, " ").tr('"', "'") }
         end
         Hash[config_pairs]
       else

data/lib/bundler/setup.rb

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

data/lib/bundler/shared_helpers.rb

@@ -28,7 +28,23 @@ module Bundler
     end
 
     def default_lockfile
-      Pathname.new("#{default_gemfile}.lock")
+      gemfile = default_gemfile
+
+      case gemfile.basename.to_s
+      when 'gems.rb' then Pathname.new(gemfile.sub(/.rb$/, '.locked'))
+      else Pathname.new("#{gemfile}.lock")
+      end
+    end
+
+    def default_bundle_dir
+      global_bundle_dir = File.join(Bundler.rubygems.user_home, ".bundle")
+      bundle_dir = find_directory(".bundle")
+
+      if bundle_dir && bundle_dir != global_bundle_dir
+        Pathname.new(bundle_dir)
+      else
+        nil
+      end
     end
 
     def in_bundle?
@@ -64,12 +80,47 @@ module Bundler
       keys.each {|key| ENV[key] = old_env[key] }
     end
 
+    def set_bundle_environment
+      # Set PATH
+      paths = (ENV["PATH"] || "").split(File::PATH_SEPARATOR)
+      paths.unshift "#{Bundler.bundle_path}/bin"
+      ENV["PATH"] = paths.uniq.join(File::PATH_SEPARATOR)
+
+      # Set RUBYOPT
+      rubyopt = [ENV["RUBYOPT"]].compact
+      if rubyopt.empty? || rubyopt.first !~ /-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__)
+      ENV["RUBYLIB"] = rubylib.uniq.join(File::PATH_SEPARATOR)
+    end
+
   private
 
     def find_gemfile
       given = ENV['BUNDLE_GEMFILE']
       return given if given && !given.empty?
 
+      find_file('Gemfile', 'gems.rb')
+    end
+
+    def find_file(*names)
+      search_up(*names) {|filename|
+        return filename if File.file?(filename)
+      }
+    end
+
+    def find_directory(*names)
+      search_up(*names) do |dirname|
+        return dirname if File.directory?(dirname)
+      end
+    end
+
+    def search_up(*names)
       previous = nil
       current  = File.expand_path(SharedHelpers.pwd)
 
@@ -79,9 +130,10 @@ module Bundler
           return nil if File.file?(File.join(current, 'bundler.gemspec'))
         end
 
-        # otherwise return the Gemfile if it's there
-        filename = File.join(current, 'Gemfile')
-        return filename if File.file?(filename)
+        names.each do |name|
+          filename = File.join(current, name)
+          yield filename
+        end
         current, previous = File.expand_path("..", current), current
       end
     end

data/lib/bundler/source.rb

@@ -21,22 +21,21 @@ module Bundler
     end
 
     def version_message(spec)
-      locked_spec = Bundler.locked_gems.specs.find { |s| s.name == spec.name } if Bundler.locked_gems
-      locked_spec_version = locked_spec.version if locked_spec
       message = "#{spec.name} #{spec.version}"
-      if locked_spec_version && spec.version != locked_spec_version
-        message << " (was #{locked_spec_version})"
+
+      if Bundler.locked_gems
+        locked_spec = Bundler.locked_gems.specs.find { |s| s.name == spec.name }
+        locked_spec_version = locked_spec.version if locked_spec
+        if locked_spec_version && spec.version != locked_spec_version
+          message << " (was #{locked_spec_version})"
+        end
       end
+
       message
     end
 
     def can_lock?(spec)
       spec.source == self
     end
-
-    def include?(other)
-      other == self
-    end
-
   end
 end

data/lib/bundler/source/git.rb

@@ -20,7 +20,7 @@ module Bundler
         # Stringify options that could be set as symbols
         %w(ref branch tag revision).each{|k| options[k] = options[k].to_s if options[k] }
 
-        @uri        = options["uri"]
+        @uri        = options["uri"] || ''
         @branch     = options["branch"]
         @ref        = options["ref"] || options["branch"] || options["tag"] || 'master'
         @submodules = options["submodules"]
@@ -46,6 +46,10 @@ module Bundler
         out << "  specs:\n"
       end
 
+      def hash
+        [self.class, uri, ref, branch, name, version, submodules].hash
+      end
+
       def eql?(o)
         o.is_a?(Git)         &&
         uri == o.uri         &&

data/lib/bundler/source/git/git_proxy.rb

@@ -60,6 +60,10 @@ module Bundler
           end
         end
 
+        def version
+          git("--version").sub("git version", "").strip
+        end
+
         def checkout
           if path.exist?
             return if has_revision_cached?

data/lib/bundler/source/path.rb

@@ -54,19 +54,19 @@ module Bundler
       end
 
       def hash
-        self.class.hash
+        [self.class, expanded_path, version].hash
       end
 
       def eql?(o)
         o.instance_of?(Path) &&
-        expand(path) == expand(o.path) &&
+        expanded_path == expand(o.path) &&
         version == o.version
       end
 
       alias == eql?
 
       def name
-        File.basename(expand(path).to_s)
+        File.basename(expanded_path.to_s)
       end
 
       def install(spec)
@@ -95,6 +95,7 @@ module Bundler
       def specs
         if has_app_cache?
           @path = app_cache_path
+          @expanded_path = nil # Invalidate
         end
         local_specs
       end
@@ -105,6 +106,10 @@ module Bundler
 
     private
 
+      def expanded_path
+        @expanded_path ||= expand(path)
+      end
+
       def expand(somepath)
         somepath.expand_path(Bundler.root)
       rescue ArgumentError => e
@@ -123,7 +128,6 @@ module Bundler
 
       def load_spec_files
         index = Index.new
-        expanded_path = expand(path)
 
         if File.directory?(expanded_path)
           Dir["#{expanded_path}/#{@glob}"].each do |file|
@@ -169,7 +173,6 @@ module Bundler
 
       def generate_bin(spec, disable_extensions = false)
         gem_dir  = Pathname.new(spec.full_gem_path)
-        gem_file = nil
 
         # Some gem authors put absolute paths in their gemspec
         # and we have to save them from themselves
@@ -183,8 +186,6 @@ module Bundler
         end.compact
 
         SharedHelpers.chdir(gem_dir) do
-          gem_file = Bundler.rubygems.build_gem gem_dir, spec
-
           installer = Path::Installer.new(spec, :env_shebang => false)
           run_hooks(:pre_install, installer)
           installer.build_extensions unless disable_extensions
@@ -204,10 +205,6 @@ module Bundler
         end
 
         Bundler.ui.warn "The validation message from Rubygems was:\n  #{e.message}"
-      ensure
-        if gem_dir && gem_file
-          FileUtils.rm_rf(gem_dir.join gem_file)
-        end
       end
 
       def run_hooks(type, installer)

data/lib/bundler/source/path/installer.rb

@@ -3,8 +3,6 @@ module Bundler
     class Path
 
       class Installer < Bundler::GemInstaller
-        attr_reader :spec
-
         def initialize(spec, options = {})
           @spec              = spec
           @tmp_bin_dir       = "#{Bundler.tmp(spec.full_name)}/bin"

data/lib/bundler/source/rubygems.rb

@@ -5,8 +5,7 @@ require 'rubygems/spec_fetcher'
 module Bundler
   class Source
     class Rubygems < Source
-      # threshold for switching back to the modern index instead of fetching every spec
-      API_REQUEST_LIMIT = 100
+      API_REQUEST_LIMIT = 100 # threshold for switching back to the modern index instead of fetching every spec
 
       attr_reader :remotes, :caches
 
@@ -34,15 +33,11 @@ module Bundler
       end
 
       def eql?(o)
-        o.is_a?(Rubygems) && o.credless_remotes == credless_remotes
+        o.is_a?(Rubygems) && remotes_equal?(o.remotes)
       end
 
       alias == eql?
 
-      def include?(o)
-        o.is_a?(Rubygems) && (o.credless_remotes - credless_remotes).empty?
-      end
-
       def can_lock?(spec)
         spec.source.is_a?(Rubygems)
       end
@@ -97,49 +92,50 @@ module Bundler
           spec.__swap__(s)
         end
 
-        path = cached_gem(spec)
-        if Bundler.requires_sudo?
-          install_path = Bundler.tmp(spec.full_name)
-          bin_path     = install_path.join("bin")
-        else
-          install_path = Bundler.rubygems.gem_dir
-          bin_path     = Bundler.system_bindir
-        end
+        unless Bundler.settings[:no_install]
+          path = cached_gem(spec)
+          if Bundler.requires_sudo?
+            install_path = Bundler.tmp(spec.full_name)
+            bin_path     = install_path.join("bin")
+          else
+            install_path = Bundler.rubygems.gem_dir
+            bin_path     = Bundler.system_bindir
+          end
 
-        installed_spec = nil
-        Bundler.rubygems.preserve_paths do
-          installed_spec = Bundler::GemInstaller.new(path,
-            :install_dir         => install_path.to_s,
-            :bin_dir             => bin_path.to_s,
-            :ignore_dependencies => true,
-            :wrappers            => true,
-            :env_shebang         => true
-          ).install
-        end
+          installed_spec = nil
+          Bundler.rubygems.preserve_paths do
+            installed_spec = Bundler::GemInstaller.new(path,
+              :install_dir         => install_path.to_s,
+              :bin_dir             => bin_path.to_s,
+              :ignore_dependencies => true,
+              :wrappers            => true,
+              :env_shebang         => true
+            ).install
+          end
 
-        # SUDO HAX
-        if Bundler.requires_sudo?
-          Bundler.rubygems.repository_subdirectories.each do |name|
-            src = File.join(install_path, name, "*")
-            dst = File.join(Bundler.rubygems.gem_dir, name)
-            if name == "extensions" && Dir.glob(src).any?
-              src = File.join(src, "*/*")
-              ext_src = Dir.glob(src).first
-              ext_src.gsub!(src[0..-6], '')
-              dst = File.dirname(File.join(dst, ext_src))
+          # SUDO HAX
+          if Bundler.requires_sudo?
+            Bundler.rubygems.repository_subdirectories.each do |name|
+              src = File.join(install_path, name, "*")
+              dst = File.join(Bundler.rubygems.gem_dir, name)
+              if name == "extensions" && Dir.glob(src).any?
+                src = File.join(src, "*/*")
+                ext_src = Dir.glob(src).first
+                ext_src.gsub!(src[0..-6], '')
+                dst = File.dirname(File.join(dst, ext_src))
+              end
+              Bundler.mkdir_p dst
+              Bundler.sudo "cp -R #{src} #{dst}" if Dir[src].any?
             end
-            Bundler.mkdir_p dst
-            Bundler.sudo "cp -R #{src} #{dst}" if Dir[src].any?
-          end
 
-          spec.executables.each do |exe|
-            Bundler.mkdir_p Bundler.system_bindir
-            Bundler.sudo "cp -R #{install_path}/bin/#{exe} #{Bundler.system_bindir}/"
+            spec.executables.each do |exe|
+              Bundler.mkdir_p Bundler.system_bindir
+              Bundler.sudo "cp -R #{install_path}/bin/#{exe} #{Bundler.system_bindir}/"
+            end
           end
+          installed_spec.loaded_from = loaded_from(spec)
         end
-
-        spec.loaded_from = "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
-        installed_spec.loaded_from = spec.loaded_from
+        spec.loaded_from = loaded_from(spec)
         ["Installing #{version_message(spec)}", spec.post_install_message]
       ensure
         if install_path && Bundler.requires_sudo?
@@ -190,21 +186,27 @@ module Bundler
         end
       end
 
-    protected
-
-      def credless_remotes
-        remotes.map(&method(:suppress_configured_credentials))
+      def fetchers
+        @fetchers ||= remotes.map do |uri|
+            Bundler::Fetcher.new(uri)
+        end
       end
 
-    private
+    protected
 
       def source_uris_for_spec(spec)
-        specs.search_all(spec.name).inject([]) do |uris, spec|
-          uris << spec.source_uri.without_credentials if spec.source_uri
+        specs.search_all(spec.name).inject([]) do |uris, s|
+          uris << s.source_uri.without_credentials if s.source_uri
           uris
         end
       end
 
+    private
+
+      def loaded_from(spec)
+        "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
+      end
+
       def cached_gem(spec)
         cached_gem = cached_path(spec)
         unless cached_gem
@@ -281,12 +283,6 @@ module Bundler
         idx
       end
 
-      def fetchers
-        @fetchers ||= remotes.map do |url|
-          Bundler::Fetcher.new(url)
-        end
-      end
-
       def api_fetchers
         fetchers.select{|f| f.use_api }
       end
@@ -313,20 +309,6 @@ module Bundler
               Bundler.ui.info "" if !Bundler.ui.debug? # new line now that the dots are over
             end
 
-            # Suppose the gem Foo depends on the gem Bar.  Foo exists in Source A.  Bar has some versions that exist in both
-            # sources A and B.  At this point, the API request will have found all the versions of Bar in source A,
-            # but will not have found any versions of Bar from source B, which is a problem if the requested version
-            # of Foo specifically depends on a version of Bar that is only found in source B. This ensures that for
-            # each spec we found, we add all possible versions from all sources to the index.
-            begin
-              idxcount = idx.size
-              api_fetchers.each do |f|
-                Bundler.ui.info "Fetching version metadata from #{f.uri}", Bundler.ui.debug?
-                idx.use f.specs(idx.dependency_names, self), true
-                Bundler.ui.info "" if !Bundler.ui.debug? # new line now that the dots are over
-              end
-            end until idxcount == idx.size
-
             if api_fetchers.any? && api_fetchers.all?{|f| f.use_api }
               # it's possible that gems from one source depend on gems from some
               # other source, so now we download gemspecs and iterate over those
@@ -335,7 +317,7 @@ module Bundler
 
               # if there are any cross-site gems we missed, get them now
               api_fetchers.each do |f|
-                Bundler.ui.info "Fetching dependency metadata from #{f.uri}", Bundler.ui.debug?
+                Bundler.ui.info "Fetching additional metadata from #{f.uri}", Bundler.ui.debug?
                 idx.use f.specs(unmet, self)
                 Bundler.ui.info "" if !Bundler.ui.debug? # new line now that the dots are over
               end if unmet.any?
@@ -366,6 +348,10 @@ module Bundler
         spec.loaded_from && spec.loaded_from.include?("specifications/default/")
       end
 
+      def remotes_equal?(other_remotes)
+        remotes.map(&method(:suppress_configured_credentials)) == other_remotes.map(&method(:suppress_configured_credentials))
+      end
+
     end
   end
 end