bundler 0.9.11 → 0.9.12

data/CHANGELOG.md

@@ -0,0 +1,109 @@
+## 0.9.12 (???)
+
+Bugfixes:
+
+  - perform a topological sort on resolved gems (#191)
+
+## 0.9.11 (March 9, 2010)
+
+  - added roadmap with future development plans
+
+Features:
+
+  - install command can take the path to the gemfile with --gemfile (#125)
+  - unknown command line options are now rejected (#163)
+  - exec command hugely sped up while locked (#177)
+  - show command prints the install path if you pass it a gem name (#148)
+  - open command edits an installed gem with $EDITOR (#148)
+  - Gemfile allows assigning an array of groups to a gem (#114)
+  - Gemfile allows :tag option on :git sources
+  - improve backtraces when a gemspec is invalid
+  - improve performance by installing gems from the cache if present
+
+Bugfixes:
+
+  - normalize parameters to Bundler.require (#153)
+  - check now checks installed gems rather than cached gems (#162)
+  - don't update the gem index when installing after locking (#169)
+  - bundle parenthesises arguments for 1.8.6 (#179)
+  - gems can now be assigned to multiple groups without problems (#135)
+  - fix the warning when building extensions for a gem from git with Rubygems 1.3.6
+  - fix a Dependency.to_yaml error due to accidentally including sources and groups
+  - don't reinstall packed gems
+  - fix gems with git sources that are private repositories
+
+## 0.9.10 (March 1, 2010)
+
+  - depends on Rubygems 1.3.6
+
+Bugfixes:
+
+  - support locking after install --without
+  - don't reinstall gems from the cache if they're already in the bundle
+  - fixes for Ruby 1.8.7 and 1.9
+
+## 0.9.9 (February 25, 2010)
+
+Bugfixes:
+
+  - don't die if GEM_HOME is an empty string
+  - fixes for Ruby 1.8.6 and 1.9
+
+## 0.9.8 (February 23, 2010)
+
+Features:
+
+  - pack command which both caches and locks
+  - descriptive error if a cached gem is missing
+  - remember the --without option after installing
+  - expand paths given in the Gemfile via the :path option
+  - add block syntax to the git and group options in the Gemfile
+  - support gems with extensions that don't admit they depend on rake
+  - generate gems using gem build gemspec so git gems can have native extensions
+  - print a useful warning if building a gem fails
+  - allow manual configuration via BUNDLE_PATH
+
+Bugfixes:
+
+  - eval gemspecs in the gem directory so relative paths work
+  - make default spec for git sources valid
+  - don't reinstall gems that are already packed
+
+## 0.9.7 (February 17, 2010)
+
+Bugfixes:
+
+  - don't say that a gem from an excluded group is "installing"
+  - improve crippling rubygems in locked scenarios
+
+## 0.9.6 (February 16, 2010)
+
+Features:
+
+  - allow String group names
+  - a number of improvements in the documentation and error messages
+
+Bugfixes:
+
+  - set SourceIndex#spec_dirs to solve a problem involving Rails 2.3 in unlocked mode
+  - ensure Rubygems is fully loaded in Ruby 1.9 before patching it
+  - fix `bundle install` for a locked app without a .bundle directory
+  - require gems in the order that the resolver determines
+  - make the tests platform agnostic so we can confirm that they're green on JRuby
+  - fixes for Ruby 1.9
+
+## 0.9.5 (Feburary 12, 2010)
+
+Features:
+
+  - added support for :path => "relative/path"
+  - added support for older versions of git
+  - added `bundle install --disable-shared-gems`
+  - Bundler.require fails silently if a library does not have a file on the load path with its name
+  - Basic support for multiple rubies by namespacing the default bundle path using the version and engine
+
+Bugfixes:
+
+  - if the bundle is locked and .bundle/environment.rb is not present when Bundler.setup is called, generate it
+  - same if it's not present with `bundle check`
+  - same if it's not present with `bundle install`

data/{README.markdown → README.md}

@@ -79,7 +79,7 @@ Note that Bundler adds all the gems without an explicit group name to the
 Groups are involved in a number of scenarios:
 
 1. When installing gems using bundle install, you can choose to leave
-   out any group by specifying `--without {group name}`. This can be
+   out any group by specifying `--without group1  group2`. This can be
    helpful if, for instance, you have a gem that you cannot compile
    in certain environments.
 2. When setting up load paths using Bundler.setup, Bundler will, by
@@ -208,8 +208,8 @@ API calls in your Gemfile, and some workarounds if you are using Rails 2.3.
 ### Rails 2.3
 
 Using Bundler 0.9 with Rails 2.3 requires adding a preinitializer, and
-making a few changes to boot.rb. The exact changes needed can be found at
-[http://gist.github.com/302406](http://gist.github.com/302406).
+making a few changes to boot.rb. A detailed description of the changes
+needed can be found in [Bundler 0.9 and Rails 2.3.5](http://andre.arko.net/2010/02/13/using-bundler-09-with-rails-235/).
 
 ### Gemfile Removals
 
@@ -274,7 +274,7 @@ Bundler 0.9 changes the following Bundler 0.8 Gemfile APIs:
 
 ## More information
 
-Explanations of common Bundler use cases can be found in [Using Bundler in Real Life](http://yehudakatz.com/2010/02/09/using-bundler-in-real-life/). The general philosophy behind Bundler 0.9 is explained at some length in [Bundler 0.9: Heading Toward 1.0](http://yehudakatz.com/2010/02/01/bundler-0-9-heading-toward-1-0/).
+Explanations of common Bundler use cases can be found in [Using Bundler in Real Life](http://yehudakatz.com/2010/02/09/using-bundler-in-real-life/). The general philosophy behind Bundler 0.9 is explained at some length in [Bundler 0.9: Heading Toward 1.0](http://yehudakatz.com/2010/02/01/bundler-0-9-heading-toward-1-0/). Using Bundler with a Rails 2.3.5 app is explained with more detail in [Bundler 0.9 and Rails 2.3.5](http://andre.arko.net/2010/02/13/using-bundler-09-with-rails-235/).
 
 ### Deploying to memory-constrained servers
 
@@ -286,12 +286,19 @@ Any remaining questions may be asked via IRC in [#carlhuda](irc://irc.freenode.n
 
 ## 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/).
+Before reporting a bug, try these troubleshooting steps:
+
+    rm -rf ~/.bundle/ ~/.gem/ .bundle/ Gemfile.lock
+    bundle install
+
+If you are still having problems, please report bugs to 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
+  - What version of Ruby you are using
+  - Whether you are using RVM, and if so what version
   - Your Gemfile
   - The command you ran to generate exception(s)
   - The exception backtrace(s)

data/ROADMAP.md

@@ -0,0 +1,51 @@
+We will be releasing one more point release (0.10.x) followed by 1.0. While
+the following reflects our current thinking, critical bugs may alter it
+somewhat.
+
+# 0.10
+
+  - No breaking changes to the Gemfile are expected
+  - We expect to modify the format of Gemfile.lock.
+    - This should be the final change; it will not change for 1.0
+    - The Gemfile.lock generated by 0.9 will continue to work until 1.0
+    - If you use Bundler 0.10, we will transparently update the format
+    - This means: you will not be able to upgrade a locked app
+     directly from 0.9 to 1.0.
+  - Bundler 0.10 will automatically generate Gemfile.lock when any
+    resolve is successful.
+  - bundle install will conservatively update Gemfile.lock from the
+    last successful resolve if the Gemfile has been modified since
+    the last use of bundler.
+    - This means that adding a new gem to the Gemfile that does not
+     conflict with existing gems will not force an update of other
+     gems.
+    - This also means that we will not force an update to previously
+     resolved dependencies as long as they are compatible with some
+     valid version of the new dependency.
+    - When removing a gem, bundle install will simply remove it, without
+     recalculating all dependencies.
+  - We will be adding `bundle update` for the case where you -do-
+    wish to re-resolve all dependencies and update everything to the
+    latest version.
+    - bundle update will also take a gem name, if you want to force
+     an update to just a single gem (and its dependencies).
+  - Add a way to install dependencies that require build options
+  - Add a way to specify groups that are opt-in at install-time,
+    rather than opt-out.
+  - Some additional features that we have tagged for 0.10. For up
+    to date information, please visit
+    http://github.com/carlhuda/bundler/issues/labels/0.10
+
+# 1.0
+
+  - No breaking changes to the Gemfile are expected
+  - No breaking changes to the Gemfile.lock are expected
+  - No major changes to the workflow are expected
+  - Reduce open bug count to 0
+  - Some additional features that require more thought. For details,
+    see http://github.com/carlhuda/bundler/issues/labels/1.0
+
+# No Breaking changes
+
+We expect no breaking changes of the Gemfile, Gemfile.lock, or
+basic workflow for 1.x releases.

data/lib/bundler.rb

@@ -4,7 +4,7 @@ require 'yaml'
 require 'bundler/rubygems_ext'
 
 module Bundler
-  VERSION = "0.9.11"
+  VERSION = "0.9.12"
 
   autoload :Definition,          'bundler/definition'
   autoload :Dependency,          'bundler/dependency'
@@ -17,6 +17,7 @@ module Bundler
   autoload :Runtime,             'bundler/runtime'
   autoload :Settings,            'bundler/settings'
   autoload :SharedHelpers,       'bundler/shared_helpers'
+  autoload :SpecSet,             'bundler/spec_set'
   autoload :Source,              'bundler/source'
   autoload :Specification,       'bundler/specification'
   autoload :UI,                  'bundler/ui'

data/lib/bundler/cli.rb

@@ -38,11 +38,12 @@ module Bundler
         Bundler.ui.error "Try running `bundle install`"
         exit 1
       else
-        not_installed = env.specs.select { |spec| !spec.loaded_from }
+        not_installed = env.requested_specs.select { |spec| !spec.loaded_from }
 
         if not_installed.any?
           not_installed.each { |s| Bundler.ui.error "#{s.name} (#{s.version}) is cached, but not installed" }
           Bundler.ui.error "Try running `bundle install`"
+          exit 1
         else
           Bundler.ui.info "The Gemfile's dependencies are satisfied"
         end
@@ -68,11 +69,13 @@ module Bundler
       remove_lockfiles if options[:relock]
 
       Installer.install(Bundler.root, Bundler.definition, opts)
-      # Ensures that .bundle/environment.rb exists
-      # TODO: Figure out a less hackish way to do this
-      Bundler.load
 
       lock if options[:relock]
+    rescue GemNotFound => e
+      if Bundler.definition.sources.empty?
+        Bundler.ui.warn "Your Gemfile doesn't have any sources. You can add one with a line like 'source :gemcutter'"
+      end
+      raise e
     end
 
     desc "lock", "Locks the bundle to the current set of dependencies, including all child dependencies."

data/lib/bundler/definition.rb

@@ -32,20 +32,6 @@ module Bundler
       @sources = sources
     end
 
-    def local_index
-      @local_index ||= begin
-        index = Index.new
-
-        sources.each do |source|
-          next unless source.respond_to?(:local_specs)
-          index = source.local_specs.merge(index)
-        end
-
-        index = Index.from_installed_gems.merge(index)
-        Index.from_cached_specs("#{Bundler.bundle_path}/cache").merge(index)
-      end
-    end
-
     def groups
       dependencies.map { |d| d.groups }.flatten.uniq
     end

data/lib/bundler/environment.rb

@@ -9,22 +9,107 @@ module Bundler
       @definition = definition
     end
 
+    def index
+      @index ||= Index.build do |idx|
+        idx.use runtime_gems
+        idx.use Index.cached_gems
+      end
+    end
+
+    def requested_specs
+      @requested_specs ||= begin
+        groups = @definition.groups - Bundler.settings.without
+        groups.map! { |g| g.to_sym }
+        groups.any? ? specs_for(groups) : []
+      end
+    end
+
   private
 
-    def group_specs(specs)
-      dependencies.each do |d|
-        spec = specs.find { |s| s.name == d.name }
-        group_spec(specs, spec, d.groups)
+    def runtime_gems
+      @runtime_gems ||= Index.build do |i|
+        sources.each do |s|
+          i.use s.local_specs if s.respond_to?(:local_specs)
+        end
+
+        i.use Index.installed_gems
       end
-      specs
     end
 
-    def group_spec(specs, spec, groups)
-      spec.groups.concat(groups)
-      spec.groups.uniq!
-      spec.dependencies.select { |d| d.type != :development }.each do |d|
-        spec = specs.find { |s| s.name == d.name }
-        group_spec(specs, spec, groups)
+    def specs_for(groups)
+      deps = dependencies.select { |d| (d.groups & groups).any? }
+      # deps.any? ? specs.for(deps) : specs
+      specs.for(deps)
+    end
+
+    # ==== Locking
+
+    def locked?
+      File.exist?("#{root}/Gemfile.lock")
+    end
+
+    def write_rb_lock
+      shared_helpers = File.read(File.expand_path("../shared_helpers.rb", __FILE__))
+      template = File.read(File.expand_path("../templates/environment.erb", __FILE__))
+      erb = ERB.new(template, nil, '-')
+      FileUtils.mkdir_p(rb_lock_file.dirname)
+      File.open(rb_lock_file, 'w') do |f|
+        f.puts erb.result(binding)
+      end
+    end
+
+    def rb_lock_file
+      root.join(".bundle/environment.rb")
+    end
+
+    def gemfile_fingerprint
+      Digest::SHA1.hexdigest(File.read("#{root}/Gemfile"))
+    end
+
+    def specs_for_lock_file
+      requested_specs.map do |s|
+        hash = {
+          :name => s.name,
+          :load_paths => s.load_paths
+        }
+        if s.respond_to?(:virtual) && s.virtual
+          hash[:virtual_spec] = s.to_ruby
+        else
+          hash[:loaded_from] = s.loaded_from.to_s
+        end
+        hash
+      end
+    end
+
+    def autorequires_for_groups(*groups)
+      groups.map! { |g| g.to_sym }
+      autorequires = Hash.new { |h,k| h[k] = [] }
+
+      ordered_deps = []
+      specs = groups.any? ? specs_for(groups) : requested_specs
+      specs.each do |g|
+        dep = @definition.dependencies.find{|d| d.name == g.name }
+        ordered_deps << dep if dep && !ordered_deps.include?(dep)
+      end
+
+      ordered_deps.each do |dep|
+        dep.groups.each do |group|
+          # If there is no autorequire, then rescue from
+          # autorequiring the gems name
+          if dep.autorequire
+            dep.autorequire.each do |file|
+              autorequires[group] << [file, true]
+            end
+          else
+            autorequires[group] << [dep.name, false]
+          end
+        end
+      end
+
+      if groups.empty?
+        autorequires
+      else
+        groups.inject({}) { |h,g| h[g] = autorequires[g]; h }
       end
     end
   end

data/lib/bundler/index.rb

@@ -1,9 +1,33 @@
 module Bundler
   class Index
-    def self.from_installed_gems
+    def self.build
+      i = new
+      yield i
+      i
+    end
+
+    def self.installed_gems
       Source::SystemGems.new.specs
     end
 
+    def self.cached_gems
+      build do |idx|
+        idx.use application_cached_gems
+        idx.use system_cached_gems
+      end
+    end
+
+    def self.application_cached_gems
+      path = "#{Bundler.root}/vendor/cache"
+      if File.directory?(path)
+        from_cached_specs(path)
+      end
+    end
+
+    def self.system_cached_gems
+      from_cached_specs("#{Bundler.bundle_path}/cache")
+    end
+
     def self.from_cached_specs(path)
       Source::GemCache.new("path" => path).specs
     end
@@ -52,28 +76,19 @@ module Bundler
       end
     end
 
-    def merge!(other)
-      other.each do |spec|
-        self << spec
+    def use(other)
+      return unless other
+      other.each do |s|
+        next if search_by_spec(s).any?
+        @specs[s.name] << s
       end
       self
     end
 
-    def merge(other)
-      dup.merge!(other)
-    end
-
-    def freeze
-      @specs.each do |k,v|
-        v.freeze
-      end
-      super
-    end
-
   private
 
     def search_by_spec(spec)
-      @specs[spec.name].select { |s| s.version == spec.version }
+      @specs[spec.name].select { |s| s.version == spec.version && s.platform == spec.platform }
     end
 
     def search_by_dependency(dependency)

data/lib/bundler/installer.rb

@@ -21,20 +21,22 @@ module Bundler
       specs.each do |spec|
         spec.source.fetch(spec) if spec.source.respond_to?(:fetch)
 
-        if spec.groups & Bundler.settings.without == spec.groups
+        unless requested_specs.include?(spec)
           Bundler.ui.debug "  * Not in requested group; skipping."
           next
         end
 
-        # unless spec.source.is_a?(Source::SystemGems)
-          Bundler.ui.info "Installing #{spec.name} (#{spec.version}) from #{spec.source} "
-        # end
+        Bundler.ui.info "Installing #{spec.name} (#{spec.version}) from #{spec.source} "
 
         spec.source.install(spec)
 
         Bundler.ui.info ""
       end
 
+      if locked?
+        write_rb_lock
+      end
+
       Bundler.ui.confirm "Your bundle is complete!"
     end
 
@@ -47,7 +49,7 @@ module Bundler
     end
 
     def specs
-      @specs ||= group_specs(resolve_locally || resolve_remotely)
+      @specs ||= resolve_locally || resolve_remotely
     end
 
   private
@@ -67,7 +69,7 @@ module Bundler
       end
 
       # Run a resolve against the locally available gems
-      specs = Resolver.resolve(actual_dependencies, local_index, source_requirements)
+      specs = Resolver.resolve(actual_dependencies, index, source_requirements)
 
       # Simple logic for now. Can improve later.
       specs.length == actual_dependencies.length && specs
@@ -76,7 +78,7 @@ module Bundler
     end
 
     def resolve_remotely
-      index # trigger building the index
+      remote_index # trigger building the index
       Bundler.ui.info "Resolving dependencies"
       source_requirements = {}
       actual_dependencies.each do |dep|
@@ -84,7 +86,7 @@ module Bundler
         source_requirements[dep.name] = dep.source.specs
       end
 
-      specs = Resolver.resolve(actual_dependencies, index, source_requirements)
+      specs = Resolver.resolve(actual_dependencies, remote_index, source_requirements)
       specs
     end
 
@@ -92,58 +94,23 @@ module Bundler
       dep.requirement.requirements.any? { |op,_| op != '=' }
     end
 
-    def index
-      @index ||= begin
-        index = Index.new
-
-        rg_sources = sources.select { |s| s.is_a?(Source::Rubygems) }
-        other_sources = sources.select { |s| !s.is_a?(Source::Rubygems)   }
+    def remote_index
+      @remote_index ||= Index.build do |idx|
+        rubygems, other = sources.partition { |s| Source::Rubygems === s }
 
-        other_sources.each do |source|
-          i = source.specs
+        other.each do |source|
           Bundler.ui.debug "Source: Processing index"
-          index = i.merge(index)
+          idx.use source.specs
         end
 
-        index = Index.from_installed_gems.merge(index)
-        index = Index.from_cached_specs("#{Bundler.bundle_path}/cache").merge(index)
+        idx.use Index.installed_gems
+        idx.use Index.cached_gems
 
-        if File.directory?("#{root}/vendor/cache")
-          index = cache_source.specs.merge(index)
-        end
-
-        rg_sources.each do |source|
-          i = source.specs
+        rubygems.each do |source|
           Bundler.ui.debug "Source: Processing index"
-          index = i.merge(index)
-        end
-
-        index
-      end
-    end
-
-    def local_index
-      @local_index ||= begin
-        index = Index.new
-
-        sources.each do |source|
-          next unless source.respond_to?(:local_specs)
-          index = source.local_specs.merge(index)
-        end
-
-        index = Index.from_installed_gems.merge(index)
-
-        if File.directory?("#{root}/vendor/cache")
-          index = cache_source.specs.merge(index).freeze
+          idx.use source.specs
         end
-
-        Index.from_cached_specs("#{Bundler.bundle_path}/cache").merge(index)
       end
     end
-
-    def cache_source
-      Source::GemCache.new("path" => "#{root}/vendor/cache")
-    end
-
   end
 end

data/lib/bundler/resolver.rb

@@ -52,15 +52,7 @@ module Bundler
         raise VersionConflict, "No compatible versions could be found for required dependencies:\n  #{output}"
         nil
       end
-      if result
-        # Dependency ordering was busted anyway. This will be revisted in 0.10
-        ordered = []
-        ordered << result['rake']
-        ordered.concat result.values
-        ordered.compact!
-        ordered.uniq!
-        ordered
-      end
+      SpecSet.new(result.values)
     end
 
     def initialize(index, source_requirements)

data/lib/bundler/runtime.rb

@@ -15,12 +15,16 @@ module Bundler
       # Has to happen first
       clean_load_path
 
-      specs = specs_for(*groups)
+      specs = groups.any? ? specs_for(groups) : requested_specs
 
       cripple_rubygems(specs)
 
       # Activate the specs
       specs.each do |spec|
+        unless spec.loaded_from
+          raise GemNotFound, "#{spec.full_name} is not installed. Try running `bundle install`."
+        end
+
         Gem.loaded_specs[spec.name] = spec
         $LOAD_PATH.unshift(*spec.load_paths)
       end
@@ -63,10 +67,6 @@ module Bundler
       Bundler.ui.info("The bundle is now locked. Use `bundle show` to list the gems in the environment.")
     end
 
-    def locked?
-      File.exist?("#{root}/Gemfile.lock") || File.exist?("#{root}/.bundle/environment.rb")
-    end
-
     def dependencies_for(*groups)
       if groups.empty?
         dependencies
@@ -75,13 +75,6 @@ module Bundler
       end
     end
 
-    def specs_for(*groups)
-      groups = @definition.groups if groups.empty?
-      groups -= Bundler.settings.without
-      groups.map! { |g| g.to_sym }
-      specs.select { |s| (s.groups & groups).any? }
-    end
-
     def specs
       @specs ||= begin
         source_requirements = {}
@@ -90,16 +83,12 @@ module Bundler
           source_requirements[dep.name] = dep.source.local_specs
         end
 
-        group_specs(Resolver.resolve(@definition.actual_dependencies, index, source_requirements))
+        Resolver.resolve(@definition.actual_dependencies, index, source_requirements)
       end
     end
 
     alias gems specs
 
-    def index
-      @definition.local_index
-    end
-
     def cache
       cache_path = "#{root}/vendor/cache/"
       FileUtils.mkdir_p(cache_path)
@@ -126,20 +115,6 @@ module Bundler
       specs.map { |s| s.load_paths }.flatten
     end
 
-    def rb_lock_file
-      root.join(".bundle/environment.rb")
-    end
-
-    def write_rb_lock
-      shared_helpers = File.read(File.expand_path("../shared_helpers.rb", __FILE__))
-      template = File.read(File.expand_path("../templates/environment.erb", __FILE__))
-      erb = ERB.new(template, nil, '-')
-      FileUtils.mkdir_p(rb_lock_file.dirname)
-      File.open(rb_lock_file, 'w') do |f|
-        f.puts erb.result(binding)
-      end
-    end
-
     def write_yml_lock
       yml = details.to_yaml
       File.open("#{root}/Gemfile.lock", 'w') do |f|
@@ -165,49 +140,5 @@ module Bundler
       end
       details
     end
-
-    def gemfile_fingerprint
-      Digest::SHA1.hexdigest(File.read("#{root}/Gemfile"))
-    end
-
-    def specs_for_lock_file
-      specs_for.map do |s|
-        hash = {}
-        hash[:loaded_from] = s.loaded_from.to_s
-        hash[:load_paths]  = s.load_paths
-        hash
-      end
-    end
-
-    def autorequires_for_groups(*groups)
-      groups.map! { |g| g.to_sym }
-      autorequires = Hash.new { |h,k| h[k] = [] }
-
-      ordered_deps = []
-      specs_for(*groups).each do |g|
-        dep = @definition.dependencies.find{|d| d.name == g.name }
-        ordered_deps << dep if dep && !ordered_deps.include?(dep)
-      end
-
-      ordered_deps.each do |dep|
-        dep.groups.each do |group|
-          # If there is no autorequire, then rescue from
-          # autorequiring the gems name
-          if dep.autorequire
-            dep.autorequire.each do |file|
-              autorequires[group] << [file, true]
-            end
-          else
-            autorequires[group] << [dep.name, false]
-          end
-        end
-      end
-
-      if groups.empty?
-        autorequires
-      else
-        groups.inject({}) { |h,g| h[g] = autorequires[g]; h }
-      end
-    end
   end
 end

data/lib/bundler/source.rb

@@ -40,6 +40,8 @@ module Bundler
           :bin_dir             => "#{Gem.dir}/bin"
 
         installer.install
+
+        spec.loaded_from = "#{Gem.dir}/specifications/#{spec.full_name}.gemspec"
       end
 
     private
@@ -62,7 +64,7 @@ module Bundler
           end
         end
 
-        index.freeze
+        index
       ensure
         Gem.sources = old
       end
@@ -131,6 +133,7 @@ module Bundler
           :bin_dir             => "#{Gem.dir}/bin"
 
         installer.install
+        spec.loaded_from = "#{Gem.dir}/specifications/#{spec.full_name}.gemspec"
       end
     end
 
@@ -152,6 +155,7 @@ module Bundler
             s.version  = Gem::Version.new(options["version"])
             s.summary  = "Fake gemspec for #{options["name"]}"
             s.relative_loaded_from = "#{options["name"]}.gemspec"
+            s.virtual  = true
           end
         end
       end
@@ -180,7 +184,7 @@ module Bundler
           raise PathError, "The path `#{path}` does not exist."
         end
 
-        index.freeze
+        index
       end
 
       def local_specs
@@ -252,7 +256,7 @@ module Bundler
         # Start by making sure the git cache is up to date
         cache
         checkout
-        @specs ||= load_spec_files
+        local_specs
       end
 
       def install(spec)
@@ -312,17 +316,17 @@ module Bundler
       def cache
         if cache_path.exist?
           Bundler.ui.info "Updating #{uri}"
-          in_cache { git "fetch --quiet #{uri} master:master" }
+          in_cache { git "fetch --quiet '#{uri}' master:master" }
         else
           Bundler.ui.info "Fetching #{uri}"
           FileUtils.mkdir_p(cache_path.dirname)
-          git "clone #{uri} #{cache_path} --bare --no-hardlinks"
+          git "clone '#{uri}' '#{cache_path}' --bare --no-hardlinks"
         end
       end
 
       def checkout
-        unless File.exist?("#{path}/.git")
-          %x(git clone --no-checkout file://#{cache_path} #{path})
+        unless File.exist?(path.join(".git"))
+          git "clone --no-checkout '#{cache_path}' '#{path}'"
         end
         Dir.chdir(path) do
           git "fetch --quiet"

data/lib/bundler/spec_set.rb

@@ -0,0 +1,65 @@
+require 'tsort'
+
+module Bundler
+  class SpecSet
+    include TSort, Enumerable
+
+    def initialize(specs)
+      @specs = specs.sort_by { |s| s.name }
+    end
+
+    def each
+      sorted.each { |s| yield s }
+    end
+
+    def length
+      @specs.length
+    end
+
+    def for(*deps)
+      specs = {}
+      deps.flatten.each do |dep|
+        current = lookup[dep.respond_to?(:name) ? dep.name : dep]
+        append_subgraph(specs, current)
+      end
+
+      sorted.select { |s| specs[s.name] }
+    end
+
+    def to_a
+      sorted.dup
+    end
+
+  private
+
+    def append_subgraph(specs, current)
+      return if specs[current.name]
+      specs[current.name] = true
+      current.dependencies.each do |dep|
+        next unless dep.type == :runtime
+        append_subgraph(specs, lookup[dep.name])
+      end
+    end
+
+    def sorted
+      @sorted ||= ([lookup['rake']] + tsort).compact.uniq
+    end
+
+    def lookup
+      @lookup ||= Hash.new do |h,k|
+        h[k] = @specs.find { |s| s.name == k }
+      end
+    end
+
+    def tsort_each_node
+      @specs.each { |s| yield s }
+    end
+
+    def tsort_each_child(s)
+      s.dependencies.sort_by { |d| d.name }.each do |d|
+        next if d.type == :development
+        yield lookup[d.name]
+      end
+    end
+  end
+end

data/lib/bundler/specification.rb

@@ -1,6 +1,6 @@
 module Bundler
   class Specification < Gem::Specification
-    attr_accessor :relative_loaded_from
+    attr_accessor :relative_loaded_from, :virtual
 
     def self.from_gemspec(gemspec)
       spec = allocate
@@ -12,7 +12,7 @@ module Bundler
 
     def loaded_from
       return super unless relative_loaded_from
-      source.path.join(relative_loaded_from)
+      source.path.join(relative_loaded_from).to_s
     end
 
     def full_gem_path

data/lib/bundler/templates/environment.erb

@@ -14,7 +14,12 @@ module Bundler
     <%= spec.inspect %>,
     <% end -%>
   ].map do |hash|
-    spec = eval(File.read(hash[:loaded_from]), binding, hash[:loaded_from])
+    if hash[:loaded_from]
+      dir = File.dirname(hash[:loaded_from])
+      spec = Dir.chdir(dir){ eval(File.read(hash[:loaded_from]), binding, hash[:loaded_from]) }
+    else
+      spec = eval(hash[:virtual_spec], binding, "<virtual spec for '#{hash[:name]}'>")
+    end
     spec.loaded_from = hash[:loaded_from]
     spec.require_paths = hash[:load_paths]
     spec

metadata

@@ -5,17 +5,18 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 11
-  version: 0.9.11
+  - 12
+  version: 0.9.12
 platform: ruby
 authors: 
 - Carl Lerche
 - Yehuda Katz
+- "Andr\xC3\xA9 Arko"
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-03-09 00:00:00 -08:00
+date: 2010-03-17 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -45,6 +46,7 @@ files:
 - lib/bundler/setup.rb
 - lib/bundler/shared_helpers.rb
 - lib/bundler/source.rb
+- lib/bundler/spec_set.rb
 - lib/bundler/specification.rb
 - lib/bundler/templates/environment.erb
 - lib/bundler/templates/Gemfile
@@ -69,15 +71,14 @@ files:
 - lib/bundler/vendor/thor.rb
 - lib/bundler.rb
 - LICENSE
-- README.markdown
-- ROADMAP.textile
+- README.md
+- ROADMAP.md
+- CHANGELOG.md
 has_rdoc: true
 homepage: http://github.com/carlhuda/bundler
 licenses: []
 
-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.
+post_install_message: 
 rdoc_options: []
 
 require_paths: 

data/ROADMAP.textile

@@ -1,51 +0,0 @@
-We will be releasing one more point release (0.10.x) followed by 1.0. While
-the following reflects our current thinking, critical bugs may alter it
-somewhat.
-
-h1. 0.10
-
-* No breaking changes to the Gemfile are expected
-* We expect to modify the format of Gemfile.lock.
-** This should be the final change; it will not change for 1.0
-** The Gemfile.lock generated by 0.9 will continue to work until 1.0
-** If you use Bundler 0.10, we will transparently update the format
-** This means: you will not be able to upgrade a locked app
-   directly from 0.9 to 1.0.
-* Bundler 0.10 will automatically generate Gemfile.lock when any
-  resolve is successful.
-* bundle install will conservatively update Gemfile.lock from the
-  last successful resolve if the Gemfile has been modified since
-  the last use of bundler.
-** This means that adding a new gem to the Gemfile that does not
-   conflict with existing gems will not force an update of other
-   gems.
-** This also means that we will not force an update to previously
-   resolved dependencies as long as they are compatible with some
-   valid version of the new dependency.
-** When removing a gem, bundle install will simply remove it, without
-   recalculating all dependencies.
-* We will be adding `bundle update` for the case where you *do*
-  wish to re-resolve all dependencies and update everything to the
-  latest version.
-** bundle update will also take a gem name, if you want to force
-   an update to just a single gem (and its dependencies).
-* Add a way to install dependencies that require build options
-* Add a way to specify groups that are opt-in at install-time,
-  rather than opt-out.
-* Some additional features that we have tagged for 0.10. For up
-  to date information, please visit
-  http://github.com/carlhuda/bundler/issues/labels/0.10
-
-h1. 1.0
-
-* No breaking changes to the Gemfile are expected
-* No breaking changes to the Gemfile.lock are expected
-* No major changes to the workflow are expected
-* Reduce open bug count to 0
-* Some additional features that require more thought. For details,
-  see http://github.com/carlhuda/bundler/issues/labels/1.0
-
-h1. No Breaking changes
-
-We expect no breaking changes of the Gemfile, Gemfile.lock, or
-basic workflow for 1.x releases.