bundler 0.9.7 → 0.9.8

data/README.markdown

@@ -30,13 +30,11 @@ root directory of your application. This can quickly be done by running
 ### Gemfile
 
 This is where you specify all of your application's dependencies. The
-following is an example. For more information, refer to
-Bundler::Dsl.
+following is an example. For more information, refer to Bundler::Dsl.
 
-    # Add :gemcutter as a source that Bundler will use
-    # to find gems listed in the manifest. At least one source
-    # should be listed. URLs maybe also be used, such as
-    # http://gems.github.com.
+    # Add :gemcutter as a source that Bundler will use to find gems listed
+    # in the manifest. At least one source should be listed. URLs may also
+    # be used, such as http://gems.github.com.
     #
     source :gemcutter
 
@@ -54,11 +52,11 @@ Bundler::Dsl.
     #
     gem "rack", "1.0.0"
 
-    # Add a git repository as a source, and add a dependency on a gem
-    # from it
+    # Add a git repository as a source. Valid options include :branch, :tag,
+    # and :ref. Next, add any gems that you want from that repo.
+    #
     git "git://github.com/indirect/rails3-generators.git"
     gem "rails3-generators"
-    
 
 ### Groups
 
@@ -91,7 +89,7 @@ Groups are involved in a number of scenarios:
    included.
 3. When auto-requiring files using Bundler.require, Bundler will,
    by default, auto-require just the `:default` group. You can specify
-   a list of groups to auto-require such as 
+   a list of groups to auto-require such as
    `Bundler.require(:default, :test)`
 
 ### Installing gems
@@ -106,6 +104,10 @@ Gems that are already installed into the system RubyGems repository will be
 referenced, rather than installed again. Every time an update is made to the
 Gemfile, run `bundle install` again to install any newly needed gems.
 
+If you want to install the gems into the project's folder, like Bundler 0.8
+and earlier did, you can run `bundle install vendor`, and the gems will
+be installed into the `vendor` subdirectory of your project.
+
 ### Locking dependencies
 
 By default, bundler will only ensure that the activated gems satisfy the
@@ -116,10 +118,15 @@ The command `bundle lock` will lock the bundle to the current set of
 resolved gems. This ensures that, until the lock file is removed,
 `bundle install` and `Bundle.setup` will always activate the same gems.
 
-When you are distributing your application, you should add the Gemfile.lock
-file to your source control, so that the set of libraries your code will
-run against are fixed. Simply run `bundle install` after checking out or
-deploying your code to ensure your libraries are present.
+When you are distributing your application, you should add the Gemfile and 
+Gemfile.lock files to your source control, so that the set of libraries your
+code will run against are fixed. Simply run  `bundle install` after checking
+out or deploying your code to ensure your libraries are present.
+
+DO NOT add the .bundle directory to your source control. The files there are
+internal to bundler and vary between machines. If you are using git, you can
+exclude all machine-specific bundler files by adding a single line to your
+.gitignore file containing `.bundle`.
 
 ### Running the application
 
@@ -137,7 +144,12 @@ To do this, include the following at the beginning of your code.
       Bundler.setup
     end
 
-    # Your application requires come here
+    # Your application's requires come here, e.g.
+    # require 'date' # a ruby standard library
+    # require 'rack' # a bundled gem
+
+    # Alternatively, you can require all the bundled libs at once
+    # Bundler.require
 
 The `bundle exec` command provides a way to run arbitrary ruby code in
 context of the bundle. For example:
@@ -151,7 +163,7 @@ shell is).
 ### Packing the bundle's gems
 
 When sharing or deploying an application, you may want to include
-everything necessary to install gem dependencies. `bundle pack` will
+everything necessary to install gem dependencies. `bundle package` will
 copy .gem files for all of the bundle's dependencies into vendor/cache.
 After that, `bundle install` will always work, since it will install the
 local .gem files, and will not contact any of the remote sources.
@@ -247,10 +259,10 @@ Bundler 0.9 changes the following Bundler 0.8 Gemfile APIs:
 
 ### API Changes
 
-1. `Bundler.require_env(:environment)` becomes 
+1. `Bundler.require_env(:environment)` becomes
    `Bundler.require(:multiple, :groups)`. You must
    now specify the default group (the default group is the
-   group made up of the gems not assigned to any group) 
+   group made up of the gems not assigned to any group)
    explicitly. So `Bundler.require_env(:test)` becomes
    `Bundler.require(:default, :test)`
 
@@ -269,3 +281,17 @@ Any remaining questions may be directed via email to the [Bundler mailing list](
 ## Reporting bugs
 
 Please report all bugs on the github issue tracker for the project, located at [http://github.com/carlhuda/bundler/issues/](http://github.com/carlhuda/bundler/issues/).
+
+The best possible scenario is a ticket with a fix for the bug and a test for the fix. If that's not possible, instructions to reproduce the issue are vitally important. If you're not sure exactly how to reproduce the issue that you are seeing, create a gist of the following information and include it in your ticket:
+
+  - Whether you have locked or not
+  - What version of bundler you are using
+  - Your Gemfile
+  - The command you ran to generate exception(s)
+  - The exception backtrace(s)
+
+If you are using Rails 2.3, please also include:
+
+  - Your boot.rb file
+  - Your preinitializer.rb file
+  - Your environment.rb file

data/lib/bundler.rb

@@ -1,10 +1,10 @@
 require 'fileutils'
 require 'pathname'
 require 'yaml'
-require 'bundler/rubygems-ext'
+require 'bundler/rubygems_ext'
 
 module Bundler
-  VERSION = "0.9.7"
+  VERSION = "0.9.8"
 
   autoload :Definition,          'bundler/definition'
   autoload :Dependency,          'bundler/dependency'

data/lib/bundler/cli.rb

@@ -53,6 +53,7 @@ module Bundler
 
       Bundler.settings[:path] = path if path
       Bundler.settings[:disable_shared_gems] = '1' if options["disable-shared-gems"]
+      Bundler.settings.without = opts[:without]
 
       remove_lockfiles if options[:relock]
 
@@ -98,11 +99,22 @@ module Bundler
       end
     end
 
-    desc "pack", "Packs all the gems to vendor/cache"
-    def pack
+    desc "cache", "Cache all the gems to vendor/cache"
+    def cache
       environment = Bundler.load
-      environment.pack
+      environment.cache
+    rescue GemNotFound => e
+      Bundler.ui.error(e.message)
+      Bundler.ui.info "Run `bundle install` to install missing gems."
+      exit 128
+    end
+
+    desc "package", "Locks and then caches all of the gems into vendor/cache"
+    def package
+      lock
+      cache
     end
+    map %w(pack) => :package
 
     desc "exec", "Run the command in context of the bundle"
     def exec(*)
@@ -142,5 +154,12 @@ module Bundler
       FileUtils.rm_f "#{Bundler.root}/Gemfile.lock"
       FileUtils.rm_f "#{Bundler.root}/.bundle/environment.rb"
     end
+
+    def self.printable_tasks
+      tasks = super.dup
+      tasks.reject!{|t| t.first =~ /cache/ }
+      tasks
+    end
+
   end
 end

data/lib/bundler/definition.rb

@@ -13,10 +13,8 @@ module Bundler
     end
 
     def self.from_lock(lockfile)
-      # gemfile_definition = from_gemfile(nil)
       locked_definition = Locked.new(YAML.load_file(lockfile))
 
-      # TODO: Switch to using equivalent?
       hash = Digest::SHA1.hexdigest(File.read("#{Bundler.root}/Gemfile"))
       unless locked_definition.hash == hash
         raise GemfileError, "You changed your Gemfile after locking. Please relock using `bundle lock`"
@@ -43,20 +41,14 @@ module Bundler
           index = source.local_specs.merge(index)
         end
 
-        Index.from_installed_gems.merge(index)
+        index = Index.from_installed_gems.merge(index)
+        Index.from_cached_specs("#{Bundler.bundle_path}/cache").merge(index)
       end
     end
 
-    # def equivalent?(other)
-    #   self.matches?(other) && other.matches?(self)
-    #   # other.matches?(self)
-    # end
-
-    # def matches?(other)
-    #   dependencies.all? do |dep|
-    #     dep =~ other.specs.find {|spec| spec.name == dep.name }
-    #   end
-    # end
+    def groups
+      dependencies.map { |d| d.groups }.flatten.uniq
+    end
 
     class Locked < Definition
       def initialize(details)

data/lib/bundler/dsl.rb

@@ -9,6 +9,7 @@ module Bundler
     end
 
     def initialize
+      @source  = nil
       @sources = []
       @dependencies = []
       @group = nil
@@ -28,22 +29,26 @@ module Bundler
     end
 
     def source(source, options = {})
-      source = case source
+      @source = case source
       when :gemcutter, :rubygems, :rubyforge then Source::Rubygems.new("uri" => "http://gemcutter.org")
       when String then Source::Rubygems.new("uri" => source)
       else source
       end
 
-      options[:prepend] ? @sources.unshift(source) : @sources << source
-      source
+      options[:prepend] ? @sources.unshift(@source) : @sources << @source
+
+      yield if block_given?
+      @source
+    ensure
+      @source = nil
     end
 
-    def path(path, options = {}, source_options = {})
-      source Source::Path.new(_normalize_hash(options).merge("path" => path)), source_options
+    def path(path, options = {}, source_options = {}, &blk)
+      source Source::Path.new(_normalize_hash(options).merge("path" => Pathname.new(path))), source_options, &blk
     end
 
-    def git(uri, options = {}, source_options = {})
-      source Source::Git.new(_normalize_hash(options).merge("uri" => uri)), source_options
+    def git(uri, options = {}, source_options = {}, &blk)
+      source Source::Git.new(_normalize_hash(options).merge("uri" => uri)), source_options, &blk
     end
 
     def to_definition
@@ -98,12 +103,14 @@ module Bundler
       # Normalize git and path options
       ["git", "path"].each do |type|
         if param = opts[type]
-          source = send(type, param, opts.dup, :prepend => true)
-          source.default_spec name, version if _version?(version)
+          options = _version?(version) ? opts.merge("name" => name, "version" => version) : opts.dup
+          source = send(type, param, options, :prepend => true)
           opts["source"] = source
         end
       end
 
+      opts["source"] ||= @source
+
       opts["group"] = group
     end
 

data/lib/bundler/index.rb

@@ -4,6 +4,17 @@ module Bundler
       Source::SystemGems.new.specs
     end
 
+    def self.from_cached_specs(path)
+      index = Index.new
+
+      Dir["#{path}/*.gem"].each do |gemfile|
+        spec = Gem::Format.from_file_by_path(gemfile).spec
+        index << spec
+      end
+
+      index
+    end
+
     def initialize
       @cache = {}
       @specs = Hash.new { |h,k| h[k] = [] }
@@ -76,7 +87,7 @@ module Bundler
       @cache[dependency.hash] ||= begin
         specs = @specs[dependency.name]
 
-        wants_prerelease = dependency.version_requirements.prerelease?
+        wants_prerelease = dependency.requirement.prerelease?
         only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
         found = specs.select { |spec| dependency =~ spec }
 

data/lib/bundler/installer.rb

@@ -16,7 +16,9 @@ module Bundler
       FileUtils.mkdir_p(Bundler.bundle_path)
 
       specs.sort_by { |s| s.name }.each do |spec|
-        if (spec.groups & options[:without]).any?
+        spec.source.fetch(spec) if spec.source.respond_to?(:fetch)
+
+        if spec.groups & Bundler.settings.without == spec.groups
           Bundler.ui.debug "  * Not in requested group; skipping."
           next
         end
@@ -81,7 +83,7 @@ module Bundler
     end
 
     def ambiguous?(dep)
-      dep.version_requirements.requirements.any? { |op,_| op != '=' }
+      dep.requirement.requirements.any? { |op,_| op != '=' }
     end
 
     def index

data/lib/bundler/remote_specification.rb

@@ -1,3 +1,6 @@
+require "uri"
+require "rubygems/spec_fetcher"
+
 module Bundler
   # Represents a lazily loaded gem specification, where the full specification
   # is on the source server in rubygems' "quick" index. The proxy object is to
@@ -40,9 +43,7 @@ module Bundler
 
     def _remote_specification
       @specification ||= begin
-        deflated = Gem::RemoteFetcher.fetcher.fetch_path(_remote_uri)
-        inflated = Gem.inflate(deflated)
-        Marshal.load(inflated)
+        Gem::SpecFetcher.new.fetch_spec([@name, @version, @platform], URI(@source_uri.to_s))
       end
     end
 

data/lib/bundler/resolver.rb

@@ -94,24 +94,24 @@ module Bundler
       #   3) Sort by number of gems available in the source.
       reqs = reqs.sort_by do |a|
         [ activated[a.name] ? 0 : 1,
-          a.version_requirements.prerelease? ? 0 : 1,
+          a.requirement.prerelease? ? 0 : 1,
           @errors[a.name]   ? 0 : 1,
           activated[a.name] ? 0 : search(a).size ]
       end
 
       debug { "Activated:\n" + activated.values.map { |a| "  #{a.name} (#{a.version})" }.join("\n") }
-      debug { "Requirements:\n" + reqs.map { |r| "  #{r.name} (#{r.version_requirements})"}.join("\n") }
+      debug { "Requirements:\n" + reqs.map { |r| "  #{r.name} (#{r.requirement})"}.join("\n") }
 
       activated = activated.dup
       # Pull off the first requirement so that we can resolve it
       current   = reqs.shift
 
-      debug { "Attempting:\n  #{current.name} (#{current.version_requirements})"}
+      debug { "Attempting:\n  #{current.name} (#{current.requirement})"}
 
       # Check if the gem has already been activated, if it has, we will make sure
       # that the currently activated gem satisfies the requirement.
       if existing = activated[current.name]
-        if current.version_requirements.satisfied_by?(existing.version)
+        if current.requirement.satisfied_by?(existing.version)
           debug { "    * [SUCCESS] Already activated" }
           @errors.delete(existing.name)
           # Since the current requirement is satisfied, we can continue resolving
@@ -120,7 +120,7 @@ module Bundler
         else
           debug { "    * [FAIL] Already activated" }
           @errors[existing.name] = [existing, current]
-          debug { current.required_by.map {|d| "      * #{d.name} (#{d.version_requirements})" }.join("\n") }
+          debug { current.required_by.map {|d| "      * #{d.name} (#{d.requirement})" }.join("\n") }
           # debug { "    * All current conflicts:\n" + @errors.keys.map { |c| "      - #{c}" }.join("\n") }
           # Since the current requirement conflicts with an activated gem, we need
           # to backtrack to the current requirement's parent and try another version
@@ -199,14 +199,14 @@ module Bundler
 
       activated[spec.name] = spec
       debug { "  Activating: #{spec.name} (#{spec.version})" }
-      debug { spec.required_by.map { |d| "    * #{d.name} (#{d.version_requirements})" }.join("\n") }
+      debug { spec.required_by.map { |d| "    * #{d.name} (#{d.requirement})" }.join("\n") }
 
       # Now, we have to loop through all child dependencies and add them to our
       # array of requirements.
       debug { "    Dependencies"}
       spec.dependencies.each do |dep|
         next if dep.type == :development
-        debug { "    * #{dep.name} (#{dep.version_requirements})" }
+        debug { "    * #{dep.name} (#{dep.requirement})" }
         dep.required_by.replace(requirement.required_by)
         dep.required_by << requirement
         reqs << dep

data/lib/bundler/{rubygems-ext.rb → rubygems_ext.rb}

@@ -12,10 +12,18 @@ module Gem
     def load_paths
       require_paths.map {|p| File.join(full_gem_path, p) }
     end
-    
+
     def groups
       @groups ||= []
     end
+
+    alias_method :old_dependencies, :dependencies
+
+    def dependencies
+      original = old_dependencies
+      original << Dependency.new("rake", ">= 0") if extensions.any? { |e| e =~ /rakefile|mkrf_conf/i }
+      original
+    end
   end
 
   class Dependency

data/lib/bundler/runtime.rb

@@ -6,7 +6,7 @@ module Bundler
 
     def initialize(*)
       super
-      if locked? # && !rb_lock_file.exist?
+      if locked?
         write_rb_lock
       end
     end
@@ -76,12 +76,10 @@ module Bundler
     end
 
     def specs_for(*groups)
+      groups = @definition.groups if groups.empty?
+      groups -= Bundler.settings.without
       groups.map! { |g| g.to_sym }
-      if groups.empty?
-        specs
-      else
-        Resolver.resolve(dependencies_for(*groups), index)
-      end
+      specs.select { |s| (s.groups & groups).any? }
     end
 
     def specs
@@ -102,18 +100,19 @@ module Bundler
       @definition.local_index
     end
 
-    def pack
-      pack_path = "#{root}/vendor/cache/"
-      FileUtils.mkdir_p(pack_path)
+    def cache
+      cache_path = "#{root}/vendor/cache/"
+      FileUtils.mkdir_p(cache_path)
 
       Bundler.ui.info "Copying .gem files into vendor/cache"
       specs.each do |spec|
         next unless spec.source.is_a?(Source::SystemGems) || spec.source.is_a?(Source::Rubygems)
         possibilities = Gem.path.map { |p| "#{p}/cache/#{spec.full_name}.gem" }
         cached_path = possibilities.find { |p| File.exist? p }
+        raise GemNotFound, "Missing gem file '#{spec.full_name}.gem'." unless cached_path
         Bundler.ui.info "  * #{File.basename(cached_path)}"
-        next if File.expand_path(File.dirname(cached_path)) == File.expand_path(pack_path)
-        FileUtils.cp(cached_path, pack_path)
+        next if File.expand_path(File.dirname(cached_path)) == File.expand_path(cache_path)
+        FileUtils.cp(cached_path, cache_path)
       end
     end
 
@@ -160,7 +159,7 @@ module Bundler
       end
 
       details["dependencies"] = @definition.dependencies.inject({}) do |h,d|
-        info = {"version" => d.version_requirements.to_s, "group" => d.groups}
+        info = {"version" => d.requirement.to_s, "group" => d.groups}
         info.merge!("require" => d.autorequire) if d.autorequire
         h.merge(d.name => info)
       end
@@ -172,7 +171,7 @@ module Bundler
     end
 
     def specs_for_lock_file
-      specs.map do |s|
+      specs_for.map do |s|
         hash = {}
         hash[:loaded_from] = s.loaded_from.to_s
         hash[:load_paths]  = s.load_paths

data/lib/bundler/settings.rb

@@ -20,6 +20,14 @@ module Bundler
       value
     end
 
+    def without=(array)
+      self[:without] = array.join(":")
+    end
+
+    def without
+      self[:without] ? self[:without].split(":").map { |w| w.to_sym } : []
+    end
+
   private
 
     def config_file

data/lib/bundler/shared_helpers.rb

@@ -1,3 +1,13 @@
+module Gem
+  class Dependency
+    if !instance_methods.map { |m| m.to_s }.include?("requirement")
+      def requirement
+        version_requirements
+      end
+    end
+  end
+end
+
 module Bundler
   module SharedHelpers
 
@@ -68,7 +78,7 @@ module Bundler
         end
         opts = reqs.last.is_a?(Hash) ? reqs.pop : {}
 
-        unless dep.respond_to?(:name) && dep.respond_to?(:version_requirements)
+        unless dep.respond_to?(:name) && dep.respond_to?(:requirement)
           dep = Gem::Dependency.new(dep, reqs)
         end
 
@@ -77,13 +87,13 @@ module Bundler
         if spec.nil?
           e = Gem::LoadError.new "#{dep.name} is not part of the bundle. Add it to Gemfile."
           e.name = dep.name
-          e.version_requirement = dep.version_requirements
+          e.version_requirement = dep.requirement
           raise e
         elsif dep !~ spec
           e = Gem::LoadError.new "can't activate #{dep}, already activated #{spec.full_name}. " \
                                  "Make sure all dependencies are added to Gemfile."
           e.name = dep.name
-          e.version_requirement = dep.version_requirements
+          e.version_requirement = dep.requirement
           raise e
         end
 

data/lib/bundler/source.rb

@@ -1,4 +1,5 @@
-require "rubygems/remote_fetcher"
+require "uri"
+require "rubygems/spec_fetcher"
 require "rubygems/format"
 require "digest/sha1"
 require "open3"
@@ -10,7 +11,8 @@ module Bundler
 
       def initialize(options = {})
         @options = options
-        @uri = options["uri"]
+        @uri = options["uri"].to_s
+        @uri = "#{uri}/" unless @uri =~ %r'/$'
         @uri = URI.parse(@uri) unless @uri.is_a?(URI)
         raise ArgumentError, "The source must be an absolute URI" unless @uri.absolute?
       end
@@ -23,13 +25,14 @@ module Bundler
         @specs ||= fetch_specs
       end
 
-      def install(spec)
-        destination = Gem.dir
-
+      def fetch(spec)
         Bundler.ui.debug "  * Downloading"
-        gem_path  = Gem::RemoteFetcher.fetcher.download(spec, uri, destination)
+        Gem::RemoteFetcher.fetcher.download(spec, uri, Gem.dir)
+      end
+
+      def install(spec)
         Bundler.ui.debug "  * Installing"
-        installer = Gem::Installer.new gem_path,
+        installer = Gem::Installer.new gem_path(spec),
           :install_dir         => Gem.dir,
           :ignore_dependencies => true,
           :wrappers            => true,
@@ -41,29 +44,32 @@ module Bundler
 
     private
 
+      def gem_path(spec)
+        "#{Gem.dir}/cache/#{spec.full_name}.gem"
+      end
+
       def fetch_specs
         index = Index.new
         Bundler.ui.info "Fetching source index from #{uri}"
-        (main_specs + prerelease_specs).each do |name, version, platform|
-          next unless Gem::Platform.match(platform)
-          spec = RemoteSpecification.new(name, version, platform, @uri)
-          spec.source = self
-          index << spec
+        old, Gem.sources = Gem.sources, ["#{uri}"]
+
+        fetch_all_specs do |n,v|
+          v.each do |name, version, platform|
+            next unless Gem::Platform.match(platform)
+            spec = RemoteSpecification.new(name, version, platform, @uri)
+            spec.source = self
+            index << spec
+          end
         end
-        index.freeze
-      end
 
-      def main_specs
-        Marshal.load(Gem::RemoteFetcher.fetcher.fetch_path("#{uri}/specs.4.8.gz"))
-      rescue Gem::RemoteFetcher::FetchError => e
-        raise ArgumentError, "#{to_s} is not a valid source: #{e.message}"
+        index.freeze
+      ensure
+        Gem.sources = old
       end
 
-      def prerelease_specs
-        Marshal.load(Gem::RemoteFetcher.fetcher.fetch_path("#{uri}/prerelease_specs.4.8.gz"))
-      rescue Gem::RemoteFetcher::FetchError
-        Bundler.ui.warn "Source '#{uri}' does not support prerelease gems"
-        []
+      def fetch_all_specs(&blk)
+        Gem::SpecFetcher.new.list(true, false).each(&blk)
+        Gem::SpecFetcher.new.list(false, true).each(&blk)
       end
     end
 
@@ -72,7 +78,7 @@ module Bundler
         @specs ||= begin
           index = Index.new
 
-          Gem::SourceIndex.from_installed_gems.each do |name, spec|
+          Gem::SourceIndex.from_installed_gems.reverse_each do |name, spec|
             spec.source = self
             index << spec
           end
@@ -101,22 +107,16 @@ module Bundler
 
       def specs
         @specs ||= begin
-          index = Index.new
-
-          Dir["#{@path}/*.gem"].each do |gemfile|
-            spec = Gem::Format.from_file_by_path(gemfile).spec
-            spec.source = self
-            index << spec
-          end
-
-          index.freeze
+          specs = Index.from_cached_specs(@path)
+          specs.each { |s| s.source = self }
+          specs
         end
       end
 
       def install(spec)
         destination = Gem.dir
 
-        Bundler.ui.debug "  * Installing from pack"
+        Bundler.ui.debug "  * Installing from cache"
         installer = Gem::Installer.new "#{@path}/#{spec.full_name}.gem",
           :install_dir         => Gem.dir,
           :ignore_dependencies => true,
@@ -129,53 +129,54 @@ module Bundler
     end
 
     class Path
-      attr_reader :path, :options
+      attr_reader :path, :options, :default_spec
 
       def initialize(options)
         @options = options
         @glob = options["glob"] || "{,*/}*.gemspec"
-        @path = options["path"]
-        @default_spec = nil
+
+        if options["path"]
+          @path = Pathname.new(options["path"]).expand_path(Bundler.root)
+        end
+
+        if options["name"]
+          @default_spec = Specification.new do |s|
+            s.name     = options["name"]
+            s.source   = self
+            s.version  = Gem::Version.new(options["version"])
+            s.summary  = "Fake gemspec for #{options["name"]}"
+            s.relative_loaded_from = "#{options["name"]}.gemspec"
+          end
+        end
       end
 
       def to_s
         "source code at #{@path}"
       end
 
-      def default_spec(*args)
-        return @default_spec if args.empty?
-        name, version = *args
-        @default_spec = Specification.new do |s|
-          s.name     = name
-          s.source   = self
-          s.version  = Gem::Version.new(version)
-          s.relative_loaded_from = "#{name}.gemspec"
-        end
-      end
-
-      def local_specs
-        @local_specs ||= begin
-          index = Index.new
+      def load_spec_files
+        index = Index.new
 
-          if File.directory?(path)
-            Dir["#{path}/#{@glob}"].each do |file|
-              file = Pathname.new(file)
-              relative_path = file.relative_path_from(Pathname.new(path))
-              # Do it in the root of the repo in case they do
-              # assume being in the root
-              if spec = Dir.chdir(path) { eval(File.read(relative_path)) }
-                spec = Specification.from_gemspec(spec)
-                spec.loaded_from = file
-                spec.source      = self
-                index << spec
-              end
+        if File.directory?(path)
+          Dir["#{path}/#{@glob}"].each do |file|
+            file = Pathname.new(file)
+            # Eval the gemspec from its parent directory
+            if spec = Dir.chdir(file.dirname) { eval(File.read(file.basename)) }
+              spec = Specification.from_gemspec(spec)
+              spec.loaded_from = file.to_s
+              spec.source = self
+              index << spec
             end
-
-            index << default_spec if default_spec && index.empty?
           end
 
-          index.freeze
+          index << default_spec if default_spec && index.empty?
         end
+
+        index.freeze
+      end
+
+      def local_specs
+        @local_specs ||= load_spec_files
       end
 
       def install(spec)
@@ -188,19 +189,35 @@ module Bundler
     private
 
       def generate_bin(spec)
-        # HAX -- Generate the bin
-        bin_dir = "#{Gem.dir}/bin"
-        gem_dir = spec.full_gem_path
-        installer = Gem::Installer.allocate
-        installer.instance_eval do
-          @spec     = spec
-          @bin_dir  = bin_dir
-          @gem_dir  = gem_dir
-          @wrappers = true
-          @env_shebang = false
-          @format_executable = false
+        gem_dir  = spec.full_gem_path
+        gem_file = nil # so we have access once after it's set in the block
+
+        Dir.chdir(gem_dir) do
+          gem_file = Gem::Builder.new(spec).build
         end
+
+        installer = Gem::Installer.new File.join(gem_dir, gem_file),
+          :bin_dir           => "#{Gem.dir}/bin",
+          :wrappers          => true,
+          :env_shebang       => false,
+          :format_executable => false
+
+        installer.instance_eval { @gem_dir = gem_dir }
+
+        installer.build_extensions
         installer.generate_bin
+      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 " \
+                        "that may not affect its functionality."
+
+        if !spec.extensions.empty? && !spec.emails.empty?
+          Bundler.ui.warn "If you need to use this package without installing it from a gem " \
+                          "repository, please contact #{spec.emails.join(", or ")} and ask them " \
+                          "to modify their .gemspec so it can work with `gem build`."
+        end
+
+        Bundler.ui.warn "The validation message from Rubygems was:\n  #{e.message}"
       end
 
     end
@@ -209,8 +226,7 @@ module Bundler
       attr_reader :uri, :ref, :options
 
       def initialize(options)
-        @options = options
-        @glob = options["glob"] || "{,*/}*.gemspec"
+        super
         @uri  = options["uri"]
         @ref  = options["ref"] || options["branch"] || 'master'
       end
@@ -225,33 +241,10 @@ module Bundler
       end
 
       def specs
-        @specs ||= begin
-          index = Index.new
-          # Start by making sure the git cache is up to date
-          cache
-          # Find all gemspecs in the repo
-          in_cache do
-            out   = %x(git ls-tree -r #{revision}).strip
-            lines = out.split("\n").select { |l| l =~ /\.gemspec$/ }
-            # Loop over the lines and extract the relative path and the
-            # git hash
-            lines.each do |line|
-              next unless line =~ %r{^(\d+) (blob|tree) ([a-f0-9]+)\t(.*)$}
-              hash, file = $3, $4
-              # Read the gemspec
-              if spec = eval(%x(git cat-file blob #{$3}))
-                spec = Specification.from_gemspec(spec)
-                spec.relative_loaded_from = file
-                spec.source = self
-                index << spec
-              end
-            end
-          end
-
-          index << default_spec if default_spec && index.empty?
-
-          index.freeze
-        end
+        # Start by making sure the git cache is up to date
+        cache
+        checkout
+        @specs ||= load_spec_files
       end
 
       def install(spec)

data/lib/bundler/specification.rb

@@ -16,7 +16,7 @@ module Bundler
     end
 
     def full_gem_path
-      loaded_from.dirname.expand_path
+      Pathname.new(loaded_from).dirname.expand_path
     end
   end
 end

data/lib/bundler/vendor/thor/core_ext/hash_with_indifferent_access.rb

@@ -65,7 +65,7 @@ class Thor
             else
               self[$1] == args.first
             end
-          else 
+          else
             self[method]
           end
         end

data/lib/bundler/vendor/thor/shell/basic.rb

@@ -105,7 +105,7 @@ class Thor
           end
 
           sentence = truncate(sentence, options[:truncate]) if options[:truncate]
-          $stdout.puts sentence  
+          $stdout.puts sentence
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bundler
 version: !ruby/object:Gem::Version 
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors: 
 - Carl Lerche
@@ -10,8 +10,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-17 00:00:00 -08:00
-default_executable: 
+date: 2010-02-23 00:00:00 -08:00
+default_executable: bundle
 dependencies: []
 
 description: 
@@ -34,7 +34,7 @@ files:
 - lib/bundler/installer.rb
 - lib/bundler/remote_specification.rb
 - lib/bundler/resolver.rb
-- lib/bundler/rubygems-ext.rb
+- lib/bundler/rubygems_ext.rb
 - lib/bundler/runtime.rb
 - lib/bundler/settings.rb
 - lib/bundler/setup.rb
@@ -69,7 +69,10 @@ has_rdoc: true
 homepage: http://github.com/carlhuda/bundler
 licenses: []
 
-post_install_message: Due to a rubygems bug, you must uninstall all older versions of bundler for 0.9 to work
+post_install_message: |
+  Due to a rubygems bug, you must uninstall older versions of the bundler gem for 0.9 to work.
+  If you still need bundler 0.8, install the 'bundler08' gem.
+
 rdoc_options: []
 
 require_paths: