bundler 0.6.0 → 0.7.0

data/README.markdown

@@ -175,11 +175,31 @@ will be compiled for the target platform without requiring that the
 Assuming a Rails app with Bundler's standard setup, add something like
 this to your top-level `.gitignore` to only keep the cache:
 
-    vendor/gems/
+    vendor/gems/*
     !vendor/gems/cache/
 
 Make sure that you explicitly `git add vendor/gems/cache` before you commit.
 
+### Gems with compile-time options
+
+Some gems require you to pass compile-time options to the gem install command.
+For instance, to install mysql, you might do:
+
+    gem install mysql -- --with-mysql-config=/usr/local/lib/mysql
+
+You can pass these options to the bundler by creating a YAML file containing
+the options in question:
+
+    mysql:
+      mysql-config: /usr/local/lib/mysql
+
+You can then point the bundler at the file:
+
+    gem bundle --build-options build_options.yml
+
+In general, you will want to keep the build options YAML out of version control,
+and provide the appropriate options for the system in question.
+
 ### Running your application
 
 The easiest way to run your application is to start it with an executable
@@ -196,7 +216,7 @@ You can use `gem exec bash` to enter a shell that will run all binaries in
 the current context.
 
 Yet another way is to manually require the environment file first. This is
-located in `[bundle_path]/environments/default.rb`. For example:
+located in `[bundle_path]/gems/environment.rb`. For example:
 
     ruby -r vendor/gems/environment.rb my_ruby_script.rb
 

data/lib/bundler.rb

@@ -19,7 +19,7 @@ require "bundler/dependency"
 require "bundler/remote_specification"
 
 module Bundler
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 
   class << self
     attr_writer :logger

data/lib/bundler/cli.rb

@@ -25,33 +25,40 @@ module Bundler
     rescue SourceNotCached => e
       Bundler.logger.error e.message
       exit 9
+    rescue ManifestFileNotFound => e
+      Bundler.logger.error e.message
+      exit 10
     end
 
     def initialize(options)
       @options = options
-      @manifest = Bundler::Environment.load(@options[:manifest])
+      @environment = Bundler::Environment.load(@options[:manifest])
     end
 
     def bundle
-      @manifest.install(@options)
+      @environment.install(@options)
     end
 
     def cache
-      @manifest.cache(@options)
+      @environment.cache(@options)
     end
 
     def prune
-      @manifest.prune(@options)
+      @environment.prune(@options)
     end
 
     def list
-      @manifest.list(@options)
+      @environment.list(@options)
+    end
+
+    def list_outdated
+      @environment.list_outdated(@options)
     end
 
     def exec
-      @manifest.setup_environment
+      @environment.setup_environment
       # w0t?
-      super(*@options[:args])
+      super(*$command)
     end
 
     def run(command)

data/lib/bundler/commands/bundle_command.rb

@@ -26,6 +26,21 @@ class Gem::Commands::BundleCommand < Gem::Command
     add_option('--list', "List all gems that are part of the active bundle") do
       options[:list] = true
     end
+
+    add_option('--list-outdated', "List all outdated gems that are part of the active bundle") do
+      options[:list_outdated] = true
+    end
+
+    add_option('-b', '--build-options OPTION_FILE', "Specify a path to a yml file with build options for binary gems") do |option_file, options|
+      if File.exist?(option_file)
+        options[:build_options] = YAML.load_file(option_file)
+      end
+    end
+
+    add_option('--only ENV', "Only expand the given environment.  To specify multiple environments, use --only multiple times.") do |env, options|
+      options[:only] ||= []
+      options[:only] << env
+    end
   end
 
   def usage
@@ -47,6 +62,8 @@ Bundle stuff
       Bundler::CLI.run(:prune, options)
     elsif options[:list]
       Bundler::CLI.run(:list, options)
+    elsif options[:list_outdated]
+      Bundler::CLI.run(:list_outdated, options)
     else
       Bundler::CLI.run(:bundle, options)
     end

data/lib/bundler/commands/exec_command.rb

@@ -1,3 +1,8 @@
+if exec = ARGV.index("exec")
+  $command = ARGV[(exec + 1)..-1]
+  ARGV.replace ARGV[0..exec]
+end
+
 class Gem::Commands::ExecCommand < Gem::Command
 
   def initialize

data/lib/bundler/dependency.rb

@@ -2,7 +2,7 @@ module Bundler
   class InvalidEnvironmentName < StandardError; end
 
   class Dependency
-    attr_reader :name, :version, :require_as, :only, :except
+    attr_reader :name, :version, :require_as, :only, :except, :bundle
 
     def initialize(name, options = {}, &block)
       options.each do |k, v|
@@ -11,9 +11,10 @@ module Bundler
 
       @name       = name
       @version    = options["version"] || ">= 0"
-      @require_as = Array(options["require_as"] || name)
+      @require_as = options["require_as"]
       @only       = options["only"]
       @except     = options["except"]
+      @bundle     = options.key?("bundle") ? options["bundle"] : true
       @block      = block
 
       if (@only && @only.include?("rubygems")) || (@except && @except.include?("rubygems"))
@@ -36,8 +37,14 @@ module Bundler
     def require_env(environment)
       return unless in?(environment)
 
-      @require_as.each do |file|
-        require file
+      if @require_as
+        Array(@require_as).each { |file| require file }
+      else
+        begin
+          require name
+        rescue LoadError
+          # Do nothing
+        end
       end
 
       @block.call if @block

data/lib/bundler/dsl.rb

@@ -2,10 +2,16 @@ module Bundler
   class ManifestFileNotFound < StandardError; end
 
   class Dsl
+    def self.evaluate(environment, file)
+      builder = new(environment)
+      builder.instance_eval(File.read(file.to_s), file.to_s, 1)
+    end
+
     def initialize(environment)
       @environment = environment
-      @sources = Hash.new { |h,k| h[k] = {} }
-      @only, @except = nil, nil
+      @directory_sources = []
+      @git_sources = {}
+      @only, @except, @directory, @git = nil, nil, nil, nil
     end
 
     def bundle_path(path)
@@ -35,18 +41,36 @@ module Bundler
       end
     end
 
-    def only(env)
-      old, @only = @only, _combine_onlys(env)
+    def only(*env)
+      old, @only = @only, _combine_only(env)
       yield
       @only = old
     end
 
-    def except(env)
-      old, @except = @except, _combine_excepts(env)
+    def except(*env)
+      old, @except = @except, _combine_except(env)
       yield
       @except = old
     end
 
+    def directory(path, options = {})
+      raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
+      @directory = DirectorySource.new(options.merge(:location => path))
+      @directory_sources << @directory
+      @environment.add_priority_source(@directory)
+      yield if block_given?
+      @directory = nil
+    end
+
+    def git(uri, options = {})
+      raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
+      @git = GitSource.new(options.merge(:uri => uri))
+      @git_sources[uri] = @git
+      @environment.add_priority_source(@git)
+      yield if block_given?
+      @git = nil
+    end
+
     def clear_sources
       @environment.clear_sources
     end
@@ -55,37 +79,22 @@ module Bundler
       options = args.last.is_a?(Hash) ? args.pop : {}
       version = args.last
 
-      options[:only] = _combine_onlys(options[:only] || options["only"])
-      options[:except] = _combine_excepts(options[:except] || options["except"])
+      if path = options.delete(:vendored_at)
+        options[:path] = path
+        warn "The :vendored_at option is deprecated. Use :path instead.\nFrom #{caller[0]}"
+      end
+
+      options[:only] = _combine_only(options[:only] || options["only"])
+      options[:except] = _combine_except(options[:except] || options["except"])
 
       dep = Dependency.new(name, options.merge(:version => version))
 
-      # OMG REFACTORZ. KTHX
-      if vendored_at = options[:vendored_at]
-        vendored_at = Pathname.new(vendored_at)
-        vendored_at = @environment.filename.dirname.join(vendored_at) if vendored_at.relative?
-
-        @sources[:directory][vendored_at.to_s] ||= begin
-          source = DirectorySource.new(
-            :name     => name,
-            :version  => version,
-            :location => vendored_at
-          )
-          @environment.add_priority_source(source)
-          true
-        end
-      elsif git = options[:git]
-        @sources[:git][git] ||= begin
-          source = GitSource.new(
-            :name    => name,
-            :version => version,
-            :uri     => git,
-            :ref     => options[:commit] || options[:tag],
-            :branch  => options[:branch]
-          )
-          @environment.add_priority_source(source)
-          true
-        end
+      if options.key?(:bundle) && !options[:bundle]
+        # We're using system gems for this one
+      elsif @git || options[:git]
+        _handle_git_option(name, version, options)
+      elsif @directory || options[:path]
+        _handle_vendored_option(name, version, options)
       end
 
       @environment.dependencies << dep
@@ -93,16 +102,66 @@ module Bundler
 
   private
 
-    def _combine_onlys(only)
+    def _handle_vendored_option(name, version, options)
+      dir, path = _find_directory_source(options[:path])
+
+      if dir
+        dir.required_specs << name
+        dir.add_spec(path, name, version) if version
+      else
+        directory options[:path] do
+          _handle_vendored_option(name, version, {})
+        end
+      end
+    end
+
+    def _find_directory_source(path)
+      if @directory
+        return @directory, Pathname.new(path || '')
+      end
+
+      path = @environment.filename.dirname.join(path)
+
+      @directory_sources.each do |s|
+        if s.location.expand_path.to_s < path.expand_path.to_s
+          return s, path.relative_path_from(s.location)
+        end
+      end
+
+      nil
+    end
+
+    def _handle_git_option(name, version, options)
+      git    = options[:git].to_s
+      ref    = options[:commit] || options[:tag]
+      branch = options[:branch]
+
+      if source = @git || @git_sources[git]
+        if ref && source.ref != ref
+          raise GitSourceError, "'#{git}' already specified with ref: #{source.ref}"
+        elsif branch && source.branch != branch
+          raise GitSourceError, "'#{git}' already specified with branch: #{source.branch}"
+        end
+
+        source.required_specs << name
+        source.add_spec(Pathname.new(options[:path] || '.'), name, version) if version
+      else
+        git(git, :ref => ref, :branch => branch) do
+          _handle_git_option(name, version, options)
+        end
+      end
+    end
+
+    def _combine_only(only)
       return @only unless only
-      only = [only].flatten.compact.uniq.map { |o| o.to_s }
+      only = Array(only).compact.uniq.map { |o| o.to_s }
       only &= @only if @only
       only
     end
 
-    def _combine_excepts(except)
+    def _combine_except(except)
       return @except unless except
-      except = [except].flatten.compact.uniq.map { |o| o.to_s }
+      except = Array(except).compact.uniq.map { |o| o.to_s }
       except |= @except if @except
       except
     end

data/lib/bundler/environment.rb

@@ -10,11 +10,11 @@ module Bundler
     attr_accessor :rubygems, :system_gems
     attr_writer :gem_path, :bindir
 
-    def self.load(gemfile = nil)
-      gemfile = gemfile ? Pathname.new(gemfile).expand_path : default_manifest_file
+    def self.load(file = nil)
+      gemfile = Pathname.new(file || default_manifest_file).expand_path
 
       unless gemfile.file?
-        raise ManifestFileNotFound, "#{filename.inspect} does not exist"
+        raise ManifestFileNotFound, "Manifest file not found: #{gemfile.to_s.inspect}"
       end
 
       new(gemfile)
@@ -32,9 +32,9 @@ module Bundler
       raise DefaultManifestNotFound
     end
 
-    def initialize(filename) #, sources, dependencies, bindir, path, rubygems, system_gems)
+    def initialize(filename)
       @filename         = filename
-      @default_sources  = [GemSource.new(:uri => "http://gems.rubyforge.org"), SystemGemSource.new({})]
+      @default_sources  = default_sources
       @sources          = []
       @priority_sources = []
       @dependencies     = []
@@ -42,20 +42,27 @@ module Bundler
       @system_gems      = true
 
       # Evaluate the Gemfile
-      builder = Dsl.new(self)
-      builder.instance_eval(File.read(filename))
+      Dsl.evaluate(self, filename)
     end
 
     def install(options = {})
+      if only_envs = options[:only]
+        dependencies.reject! { |d| !only_envs.any? {|env| d.in?(env) } }
+      end
+
+      no_bundle = dependencies.map { |dep| !dep.bundle && dep.name }.compact
+
       update = options[:update]
       cached = options[:cached]
 
       repository.install(gem_dependencies, sources,
-        :rubygems    => rubygems,
-        :system_gems => system_gems,
-        :manifest    => filename,
-        :update      => update,
-        :cached      => cached
+        :rubygems      => rubygems,
+        :system_gems   => system_gems,
+        :manifest      => filename,
+        :update        => options[:update],
+        :cached        => options[:cached],
+        :build_options => options[:build_options],
+        :no_bundle     => no_bundle
       )
       Bundler.logger.info "Done."
     end
@@ -101,6 +108,18 @@ module Bundler
       end
     end
 
+    def list_outdated(options={})
+      outdated_gems = repository.outdated_gems
+      if outdated_gems.empty?
+        Bundler.logger.info "All gems are up to date."
+      else
+        Bundler.logger.info "Outdated gems:"
+        outdated_gems.each do |name|
+          Bundler.logger.info " * #{name}"
+        end
+      end
+    end
+
     def setup_environment
       unless system_gems
         ENV["GEM_HOME"] = gem_path
@@ -145,6 +164,10 @@ module Bundler
 
   private
 
+    def default_sources
+      [GemSource.new(:uri => "http://gems.rubyforge.org"), SystemGemSource.instance]
+    end
+
     def repository
       @repository ||= Repository.new(gem_path, bindir)
     end

data/lib/bundler/repository.rb

@@ -20,22 +20,31 @@ module Bundler
         s.local = options[:cached]
       end
 
+      source_requirements = {}
+      options[:no_bundle].each do |name|
+        source_requirements[name] = SystemGemSource.instance
+      end
+
+      # Check to see whether the existing cache meets all the requirements
       begin
-        valid = Resolver.resolve(dependencies, [source_index])
+        valid = Resolver.resolve(dependencies, [source_index], source_requirements)
       rescue Bundler::GemNotFound
       end
 
-      if options[:cached]
-        sources = sources.select { |s| s.can_be_local? }
-      end
+      sources = only_local(sources) if options[:cached]
 
+      # Check the remote sources if the existing cache does not meet the requirements
+      # or the user passed --update
       if options[:update] || !valid
         Bundler.logger.info "Calculating dependencies..."
-        bundle = Resolver.resolve(dependencies, [@cache] + sources)
+        bundle = Resolver.resolve(dependencies, [@cache] + sources, source_requirements)
+        download(bundle, options)
         do_install(bundle, options)
         valid = bundle
       end
-      cleanup(valid)
+
+      generate_bins(valid, options)
+      cleanup(valid, options)
       configure(valid, options)
     end
 
@@ -53,12 +62,14 @@ module Bundler
         s.local = true
       end
 
-      sources = sources.select { |s| s.can_be_local? }
+      sources = only_local(sources)
       bundle = Resolver.resolve(dependencies, [@cache] + sources)
-      @cache.gems.each do |name, spec|
-        unless bundle.any? { |s| s.name == spec.name && s.version == spec.version }
-          Bundler.logger.info "Pruning #{spec.name} (#{spec.version}) from the cache"
-          FileUtils.rm @path.join("cache", "#{spec.full_name}.gem")
+      @cache.gems.each do |name, specs|
+        specs.each do |spec|
+          unless bundle.any? { |s| s.name == spec.name && s.version == spec.version }
+            Bundler.logger.info "Pruning #{spec.name} (#{spec.version}) from the cache"
+            FileUtils.rm @path.join("cache", "#{spec.full_name}.gem")
+          end
         end
       end
     end
@@ -67,6 +78,10 @@ module Bundler
       source_index.gems.values
     end
 
+    def outdated_gems
+      source_index.outdated.sort
+    end
+
     def source_index
       index = Gem::SourceIndex.from_gems_in(@path.join("specifications"))
       index.each { |n, spec| spec.loaded_from = @path.join("specifications", "#{spec.full_name}.gemspec") }
@@ -79,10 +94,20 @@ module Bundler
 
   private
 
-    def do_install(bundle, options)
-      bundle.download
+    def only_local(sources)
+      sources.select { |s| s.can_be_local? }
+    end
+
+    def download(bundle, options)
+      bundle.sort_by {|s| s.full_name.downcase }.each do |spec|
+        next if options[:no_bundle].include?(spec.name)
+        spec.source.download(spec)
+      end
+    end
 
+    def do_install(bundle, options)
       bundle.each do |spec|
+        next if options[:no_bundle].include?(spec.name)
         spec.loaded_from = @path.join("specifications", "#{spec.full_name}.gemspec")
         # Do nothing if the gem is already expanded
         next if @path.join("gems", spec.full_name).directory?
@@ -96,11 +121,35 @@ module Bundler
       end
     end
 
+    def generate_bins(bundle, options)
+      bundle.each do |spec|
+        next if options[:no_bundle].include?(spec.name)
+        # HAX -- Generate the bin
+        bin_dir = @bindir
+        path    = @path
+        installer = Gem::Installer.allocate
+        installer.instance_eval do
+          @spec     = spec
+          @bin_dir  = bin_dir
+          @gem_dir  = path.join("gems", "#{spec.full_name}")
+          @gem_home = path
+          @wrappers = true
+          @format_executable = false
+          @env_shebang = false
+        end
+        installer.generate_bin
+      end
+    end
+
     def expand_gemfile(spec, options)
       Bundler.logger.info "Installing #{spec.name} (#{spec.version})"
 
       gemfile = @path.join("cache", "#{spec.full_name}.gem").to_s
 
+      if build_args = options[:build_options] && options[:build_options][spec.name]
+        Gem::Command.build_args = build_args.map {|k,v| "--with-#{k}=#{v}"}
+      end
+
       installer = Gem::Installer.new(gemfile, options.merge(
         :install_dir         => @path,
         :ignore_dependencies => true,
@@ -109,25 +158,14 @@ module Bundler
         :bin_dir             => @bindir
       ))
       installer.install
+    ensure
+      Gem::Command.build_args = []
     end
 
     def expand_vendored_gem(spec, options)
       add_spec(spec)
       FileUtils.mkdir_p(@path.join("gems"))
       File.symlink(spec.location, @path.join("gems", spec.full_name))
-
-      # HAX -- Generate the bin
-      bin_dir = @bindir
-      path    = @path
-      installer = Gem::Installer.allocate
-      installer.instance_eval do
-        @spec     = spec
-        @bin_dir  = bin_dir
-        @gem_dir  = path.join("gems", "#{spec.full_name}")
-        @gem_home = path
-        @wrappers = true
-      end
-      installer.generate_bin
     end
 
     def add_spec(spec)
@@ -139,7 +177,7 @@ module Bundler
       end
     end
 
-    def cleanup(valid)
+    def cleanup(valid, options)
       to_delete = gems
       to_delete.delete_if do |spec|
         valid.any? { |other| spec.name == other.name && spec.version == other.version }
@@ -173,13 +211,9 @@ module Bundler
     def generate_environment(specs, options)
       FileUtils.mkdir_p(path)
 
-      load_paths = load_paths_for_specs(specs)
+      load_paths = load_paths_for_specs(specs, options)
       bindir     = @bindir.relative_path_from(path).to_s
       filename   = options[:manifest].relative_path_from(path).to_s
-      spec_files = specs.inject({}) do |hash, spec|
-        relative = spec.loaded_from.relative_path_from(@path).to_s
-        hash.merge!(spec.name => relative)
-      end
 
       File.open(path.join("environment.rb"), "w") do |file|
         template = File.read(File.join(File.dirname(__FILE__), "templates", "environment.erb"))
@@ -188,20 +222,27 @@ module Bundler
       end
     end
 
-    def load_paths_for_specs(specs)
+    def load_paths_for_specs(specs, options)
       load_paths = []
       specs.each do |spec|
+        next if options[:no_bundle].include?(spec.name)
         gem_path = Pathname.new(spec.full_gem_path)
-        if spec.bindir
-          load_paths << gem_path.join(spec.bindir).relative_path_from(@path).to_s
-        end
+        load_paths << load_path_for(gem_path, spec.bindir) if spec.bindir
         spec.require_paths.each do |path|
-          load_paths << gem_path.join(path).relative_path_from(@path).to_s
+          load_paths << load_path_for(gem_path, path)
         end
       end
       load_paths
     end
 
+    def load_path_for(gem_path, path)
+      gem_path.join(path).relative_path_from(@path).to_s
+    end
+
+    def spec_file_for(spec)
+      spec.loaded_from.relative_path_from(@path).to_s
+    end
+
     def require_code(file, dep)
       constraint = case
       when dep.only   then %{ if #{dep.only.inspect}.include?(env)}

data/lib/bundler/resolver.rb

@@ -36,8 +36,8 @@ module Bundler
     # ==== Returns
     # <GemBundle>,nil:: If the list of dependencies can be resolved, a
     #   collection of gemspecs is returned. Otherwise, nil is returned.
-    def self.resolve(requirements, sources)
-      resolver = new(sources)
+    def self.resolve(requirements, sources, source_requirements = {})
+      resolver = new(sources, source_requirements)
       result = catch(:success) do
         resolver.resolve(requirements, {})
         output = resolver.errors.inject("") do |o, (conflict, (origin, requirement))|
@@ -49,22 +49,38 @@ module Bundler
         raise VersionConflict, "No compatible versions could be found for required dependencies:\n  #{output}"
         nil
       end
-      result && GemBundle.new(result.values)
+      if result
+        # Order gems in order of dependencies. Every gem's dependency is at
+        # a smaller index in the array.
+        ordered = []
+        result.values.each do |spec1|
+          index = nil
+          place = ordered.detect do |spec2|
+            spec1.dependencies.any? { |d| d.name == spec2.name }
+          end
+          place ?
+            ordered.insert(ordered.index(place), spec1) :
+            ordered << spec1
+        end
+        ordered.reverse
+      end
     end
 
-    def initialize(sources)
+    def initialize(sources, source_requirements)
       @errors = {}
       @stack  = []
-      @specs  = Hash.new { |h,k| h[k] = {} }
+      @specs  = Hash.new { |h,k| h[k] = [] }
+      @by_gem = source_requirements
       @cache  = {}
       @index  = {}
 
-      sources.reverse_each do |source|
-        source.gems.values.each do |spec|
-          # TMP HAX FOR OPTZ
-          spec.source = source
-          next unless Gem::Platform.match(spec.platform)
-          @specs[spec.name][spec.version] = spec
+      sources.each do |source|
+        source.gems.each do |name, specs|
+          # Hack to work with a regular Gem::SourceIndex
+          [specs].flatten.compact.each do |spec|
+            next if @specs[spec.name].any? { |s| s.version == spec.version }
+            @specs[spec.name] << spec
+          end
         end
       end
     end
@@ -74,11 +90,15 @@ module Bundler
       # gem dependencies have been resolved.
       throw :success, activated if reqs.empty?
 
-      # Sort requirements so that the ones that are easiest to resolve are first.
-      # Easiest to resolve is defined by: Is this gem already activated? Otherwise,
-      # check the number of child dependencies this requirement has.
-      reqs = reqs.sort_by do |req|
-        activated[req.name] ? 0 : search(req).size
+      # Sort dependencies so that the ones that are easiest to resolve are first.
+      # Easiest to resolve is defined by:
+      #   1) Is this gem already activated?
+      #   2) Do the version requirements include prereleased gems?
+      #   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,
+          activated[a.name] ? 0 : search(a).size ]
       end
 
       activated = activated.dup
@@ -178,7 +198,9 @@ module Bundler
 
     def search(dependency)
       @cache[dependency.hash] ||= begin
-        @specs[dependency.name].values.select do |spec|
+        collection = @by_gem[dependency.name].gems if @by_gem[dependency.name]
+        collection ||= @specs
+        collection[dependency.name].select do |spec|
           match = dependency =~ spec
           match &= dependency.version_requirements.prerelease? if spec.version.prerelease?
           match

data/lib/bundler/source.rb

@@ -1,8 +1,23 @@
 module Bundler
+  class DirectorySourceError < StandardError; end
+  class GitSourceError < StandardError ; end
   # Represents a source of rubygems. Initially, this is only gem repositories, but
   # eventually, this will be git, svn, HTTP
   class Source
     attr_accessor :repository, :local
+
+    def initialize(options) ; end
+
+  private
+
+    def process_source_gems(gems)
+      new_gems = Hash.new { |h,k| h[k] = [] }
+      gems.values.each do |spec|
+        spec.source = self
+        new_gems[spec.name] << spec
+      end
+      new_gems
+    end
   end
 
   class GemSource < Source
@@ -38,7 +53,7 @@ module Bundler
       destination = repository.path
 
       unless destination.writable?
-        raise RubygemsRetardation
+        raise RubygemsRetardation, "destination: #{destination} is not writable"
       end
 
       # Download the gem
@@ -65,10 +80,11 @@ module Bundler
         index = Marshal.load(main_index)
       end
 
-      gems = {}
+      gems = Hash.new { |h,k| h[k] = [] }
       index.each do |name, version, platform|
         spec = RemoteSpecification.new(name, version, platform, @uri)
-        gems[spec.full_name] = spec
+        spec.source = self
+        gems[spec.name] << spec if Gem::Platform.match(spec.platform)
       end
       gems
     rescue Gem::RemoteFetcher::FetchError => e
@@ -77,8 +93,13 @@ module Bundler
   end
 
   class SystemGemSource < Source
+
+    def self.instance
+      @instance ||= new({})
+    end
+
     def initialize(options)
-      # Nothing to do
+      @source = Gem::SourceIndex.from_installed_gems
     end
 
     def can_be_local?
@@ -86,7 +107,7 @@ module Bundler
     end
 
     def gems
-      @specs ||= Gem::SourceIndex.from_installed_gems.gems
+      @gems ||= process_source_gems(@source.gems)
     end
 
     def ==(other)
@@ -98,9 +119,6 @@ module Bundler
     end
 
     def download(spec)
-      # gemfile = Pathname.new(local.loaded_from)
-      # gemfile = gemfile.dirname.join('..', 'cache', "#{local.full_name}.gem").expand_path
-      # repository.cache(File.join(Gem.dir, "cache", "#{local.full_name}.gem"))
       gemfile = Pathname.new(spec.loaded_from)
       gemfile = gemfile.dirname.join('..', 'cache', "#{spec.full_name}.gem")
       repository.cache(gemfile)
@@ -108,10 +126,6 @@ module Bundler
 
   private
 
-    def fetch_specs
-
-    end
-
   end
 
   class GemDirectorySource < Source
@@ -144,11 +158,12 @@ module Bundler
   private
 
     def fetch_specs
-      specs = {}
+      specs = Hash.new { |h,k| h[k] = [] }
 
       Dir["#{@location}/*.gem"].each do |gemfile|
         spec = Gem::Format.from_file_by_path(gemfile).spec
-        specs[spec.full_name] = spec
+        spec.source = self
+        specs[spec.name] << spec
       end
 
       specs
@@ -156,13 +171,23 @@ module Bundler
   end
 
   class DirectorySource < Source
-    attr_reader :location
+    attr_reader :location, :specs, :required_specs
 
     def initialize(options)
-      @name          = options[:name]
-      @version       = options[:version]
-      @location      = options[:location]
-      @require_paths = options[:require_paths] || %w(lib)
+      if options[:location]
+        @location = Pathname.new(options[:location]).expand_path
+      end
+      @glob           = options[:glob] || "**/*.gemspec"
+      @specs          = {}
+      @required_specs = []
+    end
+
+    def add_spec(path, name, version, require_paths = %w(lib))
+      raise DirectorySourceError, "already have a gem defined for '#{path}'" if @specs[path.to_s]
+      @specs[path.to_s] = Gem::Specification.new do |s|
+        s.name     = name
+        s.version  = Gem::Version.new(version)
+      end
     end
 
     def can_be_local?
@@ -171,67 +196,70 @@ module Bundler
 
     def gems
       @gems ||= begin
-        specs = {}
-
-        # Find any gemspec files in the directory and load those specs
-        Dir["#{location}/**/*.gemspec"].each do |file|
-          file = Pathname.new(file)
-          if spec = eval(File.read(file)) and validate_gemspec(file, spec)
-            spec.location = file.dirname.expand_path
-            specs[spec.full_name] = spec
+        # Locate all gemspecs from the directory
+        specs = locate_gemspecs
+        specs = merge_defined_specs(specs)
+
+        required_specs.each do |required|
+          unless specs.any? {|k,v| v.name == required }
+            raise DirectorySourceError, "No gemspec for '#{required}' was found in" \
+              " '#{location}'. Please explicitly specify a version."
           end
         end
 
-        # If a gemspec for the dependency was not found, add it to the list
-        if specs.keys.grep(/^#{Regexp.escape(@name)}/).empty?
-          case
-          when @version.nil?
-            raise ArgumentError, "If you use :at, you must specify the gem " \
-              "and version you wish to stand in for"
-          when !Gem::Version.correct?(@version)
-            raise ArgumentError, "If you use :at, you must specify a gem and " \
-              "version. You specified #{@version} for the version"
-          end
+        process_source_gems(specs)
+      end
+    end
 
-          default = Gem::Specification.new do |s|
-            s.name     = @name
-            s.version  = Gem::Version.new(@version) if @version
-            s.location = location
-          end
-          specs[default.full_name] = default
+    def locate_gemspecs
+      Dir["#{location}/#{@glob}"].inject({}) do |specs, file|
+        file = Pathname.new(file)
+        if spec = eval(File.read(file)) and validate_gemspec(file.dirname, spec)
+          spec.location = file.dirname.expand_path
+          specs[spec.full_name] = spec
         end
-
         specs
       end
     end
 
-    # Too aggressive apparently.
-    # ===
-    # def validate_gemspec(file, spec)
-    #   file = Pathname.new(file)
-    #   Dir.chdir(file.dirname) do
-    #     spec.validate
-    #   end
-    # rescue Gem::InvalidSpecificationException => e
-    #   file = file.relative_path_from(repository.path)
-    #   Bundler.logger.warn e.message
-    #   Bundler.logger.warn "Gemspec #{spec.name} (#{spec.version}) found at '#{file}' is not valid"
-    #   false
-    # end
-    def validate_gemspec(file, spec)
-      base = file.dirname
+    def merge_defined_specs(specs)
+      @specs.each do |path, spec|
+        # Set the spec location
+        spec.location = "#{location}/#{path}"
+
+        if existing = specs.values.find { |s| s.name == spec.name }
+          if existing.version != spec.version
+            raise DirectorySourceError, "The version you specified for #{spec.name}" \
+              " is #{spec.version}. The gemspec is #{existing.version}."
+          # Not sure if this is needed
+          # ====
+          # elsif File.expand_path(existing.location) != File.expand_path(spec.location)
+          #   raise DirectorySourceError, "The location you specified for #{spec.name}" \
+          #     " is '#{spec.location}'. The gemspec was found at '#{existing.location}'."
+          end
+        elsif !validate_gemspec(spec.location, spec)
+          raise "Your gem definition is not valid: #{spec}"
+        else
+          specs[spec.full_name] = spec
+        end
+      end
+      specs
+    end
+
+    def validate_gemspec(path, spec)
+      path = Pathname.new(path)
       msg  = "Gemspec for #{spec.name} (#{spec.version}) is invalid:"
       # Check the require_paths
-      (spec.require_paths || []).each do |path|
-        unless base.join(path).directory?
-          Bundler.logger.warn "#{msg} Missing require path: '#{path}'"
+      (spec.require_paths || []).each do |require_path|
+        unless path.join(require_path).directory?
+          Bundler.logger.warn "#{msg} Missing require path: '#{require_path}'"
           return false
         end
       end
 
       # Check the executables
       (spec.executables || []).each do |exec|
-        unless base.join(spec.bindir, exec).file?
+        unless path.join(spec.bindir, exec).file?
           Bundler.logger.warn "#{msg} Missing executable: '#{File.join(spec.bindir, exec)}'"
           return false
         end
@@ -255,6 +283,8 @@ module Bundler
   end
 
   class GitSource < DirectorySource
+    attr_reader :ref, :uri, :branch
+
     def initialize(options)
       super
       @uri = options[:uri]
@@ -281,9 +311,9 @@ module Bundler
         `git clone #{@uri} #{location} --no-hardlinks`
 
         if @ref
-          Dir.chdir(location) { `git checkout #{@ref}` }
+          Dir.chdir(location) { `git checkout --quiet #{@ref}` }
         elsif @branch && @branch != "master"
-          Dir.chdir(location) { `git checkout origin/#{@branch}` }
+          Dir.chdir(location) { `git checkout --quiet origin/#{@branch}` }
         end
       end
       super

data/lib/bundler/templates/environment.erb

@@ -20,9 +20,14 @@ module Bundler
   require "rubygems"
 
   @bundled_specs = {}
-<% spec_files.each do |name, path| -%>
-  @bundled_specs["<%= name %>"] = eval(File.read("#{dir}/<%= path %>"))
-  @bundled_specs["<%= name %>"].loaded_from = "#{dir}/<%= path %>"
+<% specs.each do |spec| -%>
+<% if options[:no_bundle].include?(spec.name) -%>
+  gem "<%= spec.name %>", "<%= spec.version %>"
+<% else -%>
+<% path = spec_file_for(spec) -%>
+  @bundled_specs["<%= spec.name %>"] = eval(File.read("#{dir}/<%= path %>"))
+  @bundled_specs["<%= spec.name %>"].loaded_from = "#{dir}/<%= path %>"
+<% end -%>
 <% end -%>
 
   def self.add_specs_to_loaded_specs
@@ -42,51 +47,62 @@ module Bundler
   def self.require_env(env = nil)
     context = Class.new do
       def initialize(env) @env = env && env.to_s ; end
-      def method_missing(*) ; end
-      def only(env)
-        old, @only = @only, _combine_onlys(env)
+      def method_missing(*) ; yield if block_given? ; end
+      def only(*env)
+        old, @only = @only, _combine_only(env.flatten)
         yield
         @only = old
       end
-      def except(env)
-        old, @except = @except, _combine_excepts(env)
+      def except(*env)
+        old, @except = @except, _combine_except(env.flatten)
         yield
         @except = old
       end
       def gem(name, *args)
-        opt = args.last || {}
-        only = _combine_onlys(opt[:only] || opt["only"])
-        except = _combine_excepts(opt[:except] || opt["except"])
+        opt = args.last.is_a?(Hash) ? args.pop : {}
+        only = _combine_only(opt[:only] || opt["only"])
+        except = _combine_except(opt[:except] || opt["except"])
         files = opt[:require_as] || opt["require_as"] || name
         files = [files] unless files.respond_to?(:each)
 
         return unless !only || only.any? {|e| e == @env }
         return if except && except.any? {|e| e == @env }
 
-        files.each { |f| require f }
+        if files = opt[:require_as] || opt["require_as"]
+          files = Array(files)
+          files.each { |f| require f }
+        else
+          begin
+            require name
+          rescue LoadError
+            # Do nothing
+          end
+        end
         yield if block_given?
         true
       end
       private
-      def _combine_onlys(only)
+      def _combine_only(only)
         return @only unless only
         only = [only].flatten.compact.uniq.map { |o| o.to_s }
         only &= @only if @only
         only
       end
-      def _combine_excepts(except)
+      def _combine_except(except)
         return @except unless except
         except = [except].flatten.compact.uniq.map { |o| o.to_s }
         except |= @except if @except
         except
       end
     end
-    context.new(env && env.to_s).instance_eval(File.read(@gemfile))
+    context.new(env && env.to_s).instance_eval(File.read(@gemfile), @gemfile, 1)
   end
 end
 
 <% if options[:rubygems] -%>
 module Gem
+  @loaded_stacks = Hash.new { |h,k| h[k] = [] }
+
   def source_index.refresh!
     super
     Bundler.add_specs_to_index

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bundler
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-23 00:00:00 -07:00
+date: 2009-11-05 00:00:00 -08:00
 default_executable: 
 dependencies: []