bundler 1.0.21 → 1.1.rc

data/lib/bundler/remote_specification.rb

@@ -12,11 +12,11 @@ module Bundler
     attr_reader :name, :version, :platform
     attr_accessor :source
 
-    def initialize(name, version, platform, source_uri)
-      @name     = name
-      @version  = version
-      @platform = platform
-      @source_uri = source_uri
+    def initialize(name, version, platform, spec_fetcher)
+      @name         = name
+      @version      = version
+      @platform     = platform
+      @spec_fetcher = spec_fetcher
     end
 
     # Needed before installs, since the arch matters then and quick
@@ -43,9 +43,7 @@ module Bundler
   private
 
     def _remote_specification
-      @specification ||= begin
-        Gem::SpecFetcher.new.fetch_spec([@name, @version, @platform], URI(@source_uri.to_s))
-      end
+      @specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
     end
 
     def method_missing(method, *args, &blk)

data/lib/bundler/resolver.rb

@@ -137,7 +137,7 @@ module Bundler
       @stack                = []
       @base                 = base
       @index                = index
-      @gems_size            = {}
+      @deps_for             = {}
       @missing_gems         = Hash.new(0)
       @source_requirements  = source_requirements
     end
@@ -248,11 +248,11 @@ module Bundler
         conflicts = Set.new
 
         # Fetch all gem versions matching the requirement
-        #
-        # TODO: Warn / error when no matching versions are found.
         matching_versions = search(current)
 
+        # If we found no versions that match the current requirement
         if matching_versions.empty?
+          # If this is a top-level Gemfile requirement
           if current.required_by.empty?
             if base = @base[current.name] and !base.empty?
               version = base.first.version
@@ -271,13 +271,14 @@ module Bundler
               end
             else
               message = "Could not find gem '#{current}' "
-              if @index.sources.include?(Bundler::Source::Rubygems)
+              if @index.source_types.include?(Bundler::Source::Rubygems)
                 message << "in any of the gem sources listed in your Gemfile."
               else
                 message << "in the gems available on this machine."
               end
             end
             raise GemNotFound, message
+          # This is not a top-level Gemfile requirement
           else
             @errors[current.name] = [nil, current]
           end
@@ -333,8 +334,13 @@ module Bundler
       length = @stack.length
       @stack << requirement.name
       retval = catch(requirement.name) do
+        # clear the search cache since the catch means we couldn't meet the
+        # requirement we need with the current constraints on search
+        clear_search_cache
+        # try to resolve the next option
         resolve(reqs, activated)
       end
+
       # Since we're doing a lot of throw / catches. A push does not necessarily match
       # up to a pop. So, we simply slice the stack back to what it was before the catch
       # block.
@@ -343,7 +349,11 @@ module Bundler
     end
 
     def gems_size(dep)
-      @gems_size[dep] ||= search(dep).size
+      search(dep).size
+    end
+
+    def clear_search_cache
+      @deps_for = {}
     end
 
     def search(dep)
@@ -353,22 +363,25 @@ module Bundler
       else
         d = dep.dep
       end
-      index = @source_requirements[d.name] || @index
-      results = index.search_for_all_platforms(d, @base[d.name])
-
-      if results.any?
-        version = results.first.version
-        nested  = [[]]
-        results.each do |spec|
-          if spec.version != version
-            nested << []
-            version = spec.version
+
+      @deps_for[d.hash] ||= begin
+        index = @source_requirements[d.name] || @index
+        results = index.search(d, @base[d.name])
+
+        if results.any?
+          version = results.first.version
+          nested  = [[]]
+          results.each do |spec|
+            if spec.version != version
+              nested << []
+              version = spec.version
+            end
+            nested.last << spec
           end
-          nested.last << spec
+          deps = nested.map{|a| SpecGroup.new(a) }.select{|sg| sg.for?(dep.__platform) }
+        else
+          deps = []
         end
-        nested.map { |a| SpecGroup.new(a) }.select { |sg| sg.for?(dep.__platform) }
-      else
-        []
       end
     end
 

data/lib/bundler/rubygems_ext.rb

@@ -7,6 +7,7 @@ end
 
 require 'rubygems'
 require 'rubygems/specification'
+require 'bundler/match_platform'
 
 module Gem
   @loaded_stacks = Hash.new { |h,k| h[k] = [] }
@@ -70,22 +71,6 @@ module Gem
       dependencies - development_dependencies
     end
 
-    def add_bundler_dependencies(*groups)
-      Bundler.ui.warn "#add_bundler_dependencies is deprecated and will " \
-        "be removed in Bundler 1.0. Instead, please use the #gemspec method " \
-        "in your Gemfile, which will pull in any dependencies specified in " \
-        "your gemspec"
-
-      groups = [:default] if groups.empty?
-      Bundler.definition.dependencies.each do |dep|
-        if dep.groups.include?(:development)
-          self.add_development_dependency(dep.name, dep.requirement.to_s)
-        elsif (dep.groups & groups).any?
-          self.add_dependency(dep.name, dep.requirement.to_s)
-        end
-      end
-    end
-
   private
 
     def dependencies_to_gemfile(dependencies, group = nil)
@@ -159,79 +144,10 @@ module Gem
 
     alias eql? ==
   end
-
-end
-
-module Bundler
-  class DepProxy
-
-    attr_reader :required_by, :__platform, :dep
-
-    def initialize(dep, platform)
-      @dep, @__platform, @required_by = dep, platform, []
-    end
-
-    def hash
-      @hash ||= dep.hash
-    end
-
-    def ==(o)
-      dep == o.dep && __platform == o.__platform
-    end
-
-    alias eql? ==
-
-    def type
-      @dep.type
-    end
-
-    def to_s
-      "#{name} (#{requirement}) #{__platform}"
-    end
-
-  private
-
-    def method_missing(*args)
-      @dep.send(*args)
-    end
-
-  end
-
-  module GemHelpers
-
-    GENERIC_CACHE = {}
-    GENERICS = [
-      Gem::Platform::JAVA,
-      Gem::Platform::MSWIN,
-      Gem::Platform::MINGW,
-      Gem::Platform::RUBY
-    ]
-
-    def generic(p)
-      return p if p == Gem::Platform::RUBY
-
-      GENERIC_CACHE[p] ||= begin
-        found = GENERICS.find do |p2|
-          p2.is_a?(Gem::Platform) && p.os == p2.os
-        end
-        found || Gem::Platform::RUBY
-      end
-    end
-  end
-
-  module MatchPlatform
-    include GemHelpers
-
-    def match_platform(p)
-      Gem::Platform::RUBY == platform or
-      platform.nil? or p == platform or
-      generic(Gem::Platform.new(platform)) == p
-    end
-  end
 end
 
 module Gem
   class Specification
-    include Bundler::MatchPlatform
+    include ::Bundler::MatchPlatform
   end
 end

data/lib/bundler/rubygems_integration.rb

@@ -266,8 +266,43 @@ module Bundler
       end
     end
 
+    # This backports base_dir which replaces installation path
+    # Rubygems 1.8+
+    def backport_base_dir
+      Gem::Specification.send(:define_method, :base_dir) do
+        installation_path
+      end
+    end
+
+    def backport_cache_file
+      Gem::Specification.send(:define_method, :cache_dir) do
+        @cache_dir ||= File.join base_dir, "cache"
+      end
+
+      Gem::Specification.send(:define_method, :cache_file) do
+        @cache_file ||= File.join cache_dir, "#{full_name}.gem"
+      end
+    end
+
+    def backport_spec_file
+      Gem::Specification.send(:define_method, :spec_dir) do
+        @spec_dir ||= File.join base_dir, "specifications"
+      end
+
+      Gem::Specification.send(:define_method, :spec_file) do
+        @spec_file ||= File.join spec_dir, "#{full_name}.gemspec"
+      end
+    end
+
     # Rubygems 1.4 through 1.6
     class Legacy < RubygemsIntegration
+      def initialize
+        super
+        backport_base_dir
+        backport_cache_file
+        backport_spec_file
+      end
+
       def stub_rubygems(specs)
         stub_source_index137(specs)
       end

data/lib/bundler/runtime.rb

@@ -69,7 +69,18 @@ module Bundler
           end
         rescue LoadError => e
           REGEXPS.find { |r| r =~ e.message }
-          raise if dep.autorequire || $1 != required_file
+
+          if dep.name.include?('-')
+            begin
+              namespaced_file = dep.name.gsub('-', '/')
+              Kernel.require namespaced_file
+            rescue LoadError
+              REGEXPS.find { |r| r =~ e.message }
+              raise if dep.autorequire || $1.gsub('-', '/') != namespaced_file
+            end
+          else
+            raise if dep.autorequire || $1 != required_file
+          end
         end
       end
     end
@@ -119,6 +130,78 @@ module Bundler
       end
     end
 
+    def clean
+      gem_bins             = Dir["#{Gem.dir}/bin/*"]
+      git_dirs             = Dir["#{Gem.dir}/bundler/gems/*"]
+      git_cache_dirs       = Dir["#{Gem.dir}/cache/bundler/git/*"]
+      gem_dirs             = Dir["#{Gem.dir}/gems/*"]
+      gem_files            = Dir["#{Gem.dir}/cache/*.gem"]
+      gemspec_files        = Dir["#{Gem.dir}/specifications/*.gemspec"]
+      spec_gem_paths       = []
+      spec_git_paths       = []
+      spec_git_cache_dirs  = []
+      spec_gem_executables = []
+      spec_cache_paths     = []
+      spec_gemspec_paths   = []
+      specs.each do |spec|
+        spec_gem_paths << spec.full_gem_path
+        # need to check here in case gems are nested like for the rails git repo
+        md = %r{(.+bundler/gems/.+-[a-f0-9]{12})}.match(spec.full_gem_path)
+        spec_git_paths << md[1] if md
+        spec_gem_executables << spec.executables.collect do |executable|
+          "#{Gem.dir}/#{spec.bindir}/#{executable}"
+        end
+        spec_cache_paths << spec.cache_file
+        spec_gemspec_paths << spec.spec_file
+        spec_git_cache_dirs << spec.source.cache_path.to_s if spec.source.is_a?(Bundler::Source::Git)
+      end
+      spec_gem_paths.uniq!
+      spec_gem_executables.flatten!
+
+      stale_gem_bins       = gem_bins - spec_gem_executables
+      stale_git_dirs       = git_dirs - spec_git_paths
+      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
+
+      stale_gem_bins.each {|bin| FileUtils.rm(bin) }
+      output = stale_gem_dirs.collect do |gem_dir|
+        full_name = Pathname.new(gem_dir).basename.to_s
+
+        FileUtils.rm_rf(gem_dir)
+
+        parts   = full_name.split('-')
+        name    = parts[0..-2].join('-')
+        version = parts.last
+        output  = "#{name} (#{version})"
+
+        Bundler.ui.info "Removing #{output}"
+
+        output
+      end + stale_git_dirs.collect do |gem_dir|
+        full_name = Pathname.new(gem_dir).basename.to_s
+
+        FileUtils.rm_rf(gem_dir)
+
+        parts    = full_name.split('-')
+        name     = parts[0..-3].join('-')
+        revision = parts[-1]
+        version  = parts[-2]
+        output   = "#{name} (#{version} #{revision})"
+
+        Bundler.ui.info "Removing #{output}"
+
+        output
+      end
+
+      stale_gem_files.each {|file| FileUtils.rm(file) if File.exists?(file) }
+      stale_gemspec_files.each {|file| FileUtils.rm(file) if File.exists?(file) }
+      stale_git_cache_dirs.each {|dir| FileUtils.rm_rf(dir) if File.exists?(dir) }
+
+      output
+    end
+
   private
 
     def cache_path

data/lib/bundler/source.rb

@@ -10,20 +10,20 @@ module Bundler
   module Source
     # TODO: Refactor this class
     class Rubygems
-      attr_reader :remotes
+      FORCE_MODERN_INDEX_LIMIT = 100 # threshold for switching back to the modern index instead of fetching every spec
+
+      attr_reader :remotes, :caches
+      attr_accessor :dependency_names
 
       def initialize(options = {})
         @options = options
         @remotes = (options["remotes"] || []).map { |r| normalize_uri(r) }
+        @fetchers = {}
         @allow_remote = false
         @allow_cached = false
 
-        # Hardcode the paths for now
-        @caches = [ Bundler.app_cache ] + Bundler.rubygems.gem_path.map do |x|
-          File.expand_path("#{x}/cache")
-        end
-
-        @spec_fetch_map = {}
+        @caches = [ Bundler.app_cache ] +
+          Bundler.rubygems.gem_path.map{|p| File.expand_path("#{p}/cache") }
       end
 
       def remote!
@@ -70,15 +70,6 @@ module Bundler
         @specs ||= fetch_specs
       end
 
-      def fetch(spec)
-        spec, uri = @spec_fetch_map[spec.full_name]
-        if spec
-          path = download_gem_from_uri(spec, uri)
-          s = Bundler.rubygems.spec_from_gem(path)
-          spec.__swap__(s)
-        end
-      end
-
       def install(spec)
         if installed_specs[spec].any?
           Bundler.ui.info "Using #{spec.name} (#{spec.version}) "
@@ -87,38 +78,43 @@ module Bundler
 
         Bundler.ui.info "Installing #{spec.name} (#{spec.version}) "
         path = cached_gem(spec)
+        if Bundler.requires_sudo?
+          install_path = Bundler.tmp
+          bin_path     = install_path.join("bin")
+        else
+          install_path = Bundler.rubygems.gem_dir
+          bin_path     = Bundler.system_bindir
+        end
 
         Bundler.rubygems.preserve_paths do
+          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
 
-          install_path = Bundler.requires_sudo? ? Bundler.tmp : Bundler.rubygems.gem_dir
-          options = { :install_dir         => install_path,
-                      :ignore_dependencies => true,
-                      :wrappers            => true,
-                      :env_shebang         => true }
-          options.merge!(:bin_dir => "#{install_path}/bin") unless spec.executables.nil? || spec.executables.empty?
-
-          installer = Bundler::GemInstaller.new path, options
-          installer.install
+        if spec.post_install_message
+          Installer.post_install_messages[spec.name] = spec.post_install_message
         end
 
         # SUDO HAX
         if Bundler.requires_sudo?
-          sudo "mkdir -p #{Bundler.rubygems.gem_dir}/gems #{Bundler.rubygems.gem_dir}/specifications"
-          sudo "cp -R #{Bundler.tmp}/gems/#{spec.full_name} #{Bundler.rubygems.gem_dir}/gems/"
-          sudo "cp -R #{Bundler.tmp}/specifications/#{spec.full_name}.gemspec #{Bundler.rubygems.gem_dir}/specifications/"
+          Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/gems"
+          Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/specifications"
+          Bundler.sudo "cp -R #{Bundler.tmp}/gems/#{spec.full_name} #{Bundler.rubygems.gem_dir}/gems/"
+          Bundler.sudo "cp -R #{Bundler.tmp}/specifications/#{spec.full_name}.gemspec #{Bundler.rubygems.gem_dir}/specifications/"
           spec.executables.each do |exe|
-            sudo "mkdir -p #{Bundler.rubygems.gem_bindir}"
-            sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Bundler.rubygems.gem_bindir}"
+            Bundler.mkdir_p Bundler.system_bindir
+            Bundler.sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Bundler.system_bindir}"
           end
         end
 
         spec.loaded_from = "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
       end
 
-      def sudo(str)
-        Bundler.sudo(str)
-      end
-
       def cache(spec)
         cached_path = cached_gem(spec)
         raise GemNotFound, "Missing gem file '#{spec.full_name}.gem'." unless cached_path
@@ -228,56 +224,43 @@ module Bundler
           idx     = Index.new
           old     = Bundler.rubygems.sources
 
+          sources = {}
           remotes.each do |uri|
-            Bundler.ui.info "Fetching source index for #{uri}"
-            Gem.sources = ["#{uri}"]
-            fetch_all_remote_specs do |n,v|
-              v.each do |name, version, platform|
-                next if name == 'bundler'
-                spec = RemoteSpecification.new(name, version, platform, uri)
-                spec.source = self
-                @spec_fetch_map[spec.full_name] = [spec, uri]
-                idx << spec
+            fetcher          = Bundler::Fetcher.new(uri)
+            specs            = fetcher.specs(dependency_names, self)
+            sources[fetcher] = specs.size
+
+            idx.use specs
+          end
+
+          # don't need to fetch all specifications for every gem/version on
+          # the rubygems repo if there's no api endpoints to search over
+          # or it has too many specs to fetch
+          fetchers              = sources.keys
+          api_fetchers          = fetchers.select {|fetcher| fetcher.has_api }
+          modern_index_fetchers = fetchers - api_fetchers
+          if api_fetchers.any? && modern_index_fetchers.all? {|fetcher| sources[fetcher] < FORCE_MODERN_INDEX_LIMIT }
+            # this will fetch all the specifications on the rubygems repo
+            unmet_dependency_names = idx.unmet_dependency_names
+            unmet_dependency_names -= ['bundler'] # bundler will always be unmet
+
+            Bundler.ui.debug "Unmet Dependencies: #{unmet_dependency_names}"
+            if unmet_dependency_names.any?
+              api_fetchers.each do |fetcher|
+                idx.use fetcher.specs(unmet_dependency_names, self)
               end
             end
+          else
+            Bundler::Fetcher.disable_endpoint = true
+            api_fetchers.each {|fetcher| idx.use fetcher.specs([], self) }
           end
+
           idx
         ensure
           Bundler.rubygems.sources = old
         end
       end
 
-      def fetch_all_remote_specs(&blk)
-        begin
-          # Fetch all specs, minus prerelease specs
-          Gem::SpecFetcher.new.list(true, false).each(&blk)
-          # Then fetch the prerelease specs
-          begin
-            Gem::SpecFetcher.new.list(false, true).each(&blk)
-          rescue Gem::RemoteFetcher::FetchError
-            Bundler.ui.warn "Could not fetch prerelease specs from #{self}"
-          end
-        rescue Gem::RemoteFetcher::FetchError
-          Bundler.ui.warn "Could not reach #{self}"
-        end
-      end
-
-      def download_gem_from_uri(spec, uri)
-        spec.fetch_platform
-
-        download_path = Bundler.requires_sudo? ? Bundler.tmp : Bundler.rubygems.gem_dir
-        gem_path = "#{Bundler.rubygems.gem_dir}/cache/#{spec.full_name}.gem"
-
-        FileUtils.mkdir_p("#{download_path}/cache")
-        Bundler.rubygems.download_gem(spec, uri, download_path)
-
-        if Bundler.requires_sudo?
-          sudo "mkdir -p #{Bundler.rubygems.gem_dir}/cache"
-          sudo "mv #{Bundler.tmp}/cache/#{spec.full_name}.gem #{gem_path}"
-        end
-
-        gem_path
-      end
     end
 
     class Path
@@ -381,7 +364,7 @@ module Bundler
         index
       end
 
-      def local_specs
+      def local_specs(*)
         @local_specs ||= load_spec_files
       end
 
@@ -456,8 +439,11 @@ module Bundler
         gem_file = Dir.chdir(gem_dir){ Gem::Builder.new(spec).build }
 
         installer = Installer.new(spec, :env_shebang => false)
+        run_hooks(:pre_install, installer)
         installer.build_extensions
+        run_hooks(:post_build, installer)
         installer.generate_bin
+        run_hooks(:post_install, installer)
       rescue Gem::InvalidSpecificationException => e
         Bundler.ui.warn "\n#{spec.name} at #{spec.full_gem_path} did not have a valid gemspec.\n" \
                         "This prevents bundler from installing bins or native extensions, but " \
@@ -474,6 +460,18 @@ module Bundler
         Dir.chdir(gem_dir){ FileUtils.rm_rf(gem_file) if gem_file && File.exist?(gem_file) }
       end
 
+      def run_hooks(type, installer)
+        hooks_meth = "#{type}_hooks"
+        return unless Gem.respond_to?(hooks_meth)
+        Gem.send(hooks_meth).each do |hook|
+          result = hook.call(installer)
+          if result == false
+            location = " at #{$1}" if hook.inspect =~ /@(.*:\d+)/
+            message = "#{type} hook#{location} failed for #{installer.spec.full_name}"
+            raise Gem::InstallError, message
+          end
+        end
+      end
     end
 
     class Git < Path
@@ -545,7 +543,7 @@ module Bundler
       end
 
       # TODO: actually cache git specs
-      def specs
+      def specs(*)
         if allow_git_ops? && !@update
           # Start by making sure the git cache is up to date
           cache
@@ -572,6 +570,17 @@ module Bundler
         raise GitError, "#{to_s} is not checked out. Please run `bundle install`"
       end
 
+      def cache_path
+        @cache_path ||= begin
+          git_scope = "#{base_name}-#{uri_hash}"
+
+          if Bundler.requires_sudo?
+            Bundler.user_bundle_path.join("cache/git", git_scope)
+          else
+            Bundler.cache.join("git", git_scope)
+          end
+        end
+      end
     private
 
       def git(command)
@@ -628,18 +637,6 @@ module Bundler
         end
       end
 
-      def cache_path
-        @cache_path ||= begin
-          git_scope = "#{base_name}-#{uri_hash}"
-
-          if Bundler.requires_sudo?
-            Bundler.user_bundle_path.join("cache/git", git_scope)
-          else
-            Bundler.cache.join("git", git_scope)
-          end
-        end
-      end
-
       def cache
         if cached?
           return if has_revision_cached?

data/lib/bundler/spec_set.rb

@@ -79,8 +79,10 @@ module Bundler
 
     def materialize(deps, missing_specs = nil)
       materialized = self.for(deps, [], false, true).to_a
+      deps = materialized.map {|s| s.name }.uniq
       materialized.map! do |s|
         next s unless s.is_a?(LazySpecification)
+        s.source.dependency_names = deps if s.source.respond_to?(:dependency_names=)
         spec = s.__materialize__
         if missing_specs
           missing_specs << s unless spec

data/lib/bundler/templates/Executable

@@ -1,4 +1,4 @@
-#!/usr/bin/env <%= RbConfig::CONFIG['ruby_install_name'] %>
+#!/usr/bin/env <%= Bundler.settings[:shebang] || RbConfig::CONFIG['ruby_install_name'] %>
 #
 # This file was generated by Bundler.
 #

data/lib/bundler/templates/newgem/Gemfile.tt

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 
 # Specify your gem's dependencies in <%=config[:name]%>.gemspec
 gemspec

data/lib/bundler/templates/newgem/Rakefile.tt

@@ -1 +1,2 @@
+#!/usr/bin/env rake
 require "bundler/gem_tasks"