bundler 0.4.1 → 0.5.0

data/README.markdown

@@ -149,6 +149,11 @@ If the `disable_rubygems` option is used, Bundler will stub out the most common
 of these features, but it is possible that things will not go as intended quite
 yet. So, if you are brave, try your code without rubygems at runtime.
 
+## Known Issues
+
+* When a gem points to a git repository, the git repository will be cloned
+  every time Bundler does a gem dependency resolve.
+
 ## Reporting bugs
 
 Please report all bugs on the github issue tracker for the project located

data/Rakefile

@@ -1,12 +1,10 @@
 require 'rubygems' unless ENV['NO_RUBYGEMS']
-require 'rake/gempackagetask'
 require 'rubygems/specification'
 require 'date'
-require 'spec/rake/spectask'
 
 spec = Gem::Specification.new do |s|
   s.name    = "bundler"
-  s.version = "0.4.1"
+  s.version = "0.5.0"
   s.author  = "Yehuda Katz"
   s.email   = "wycats@gmail.com"
   s.homepage = "http://github.com/wycats/bundler"
@@ -24,15 +22,26 @@ end
 
 task :default => :spec
 
-desc "Run specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb'] - FileList['spec/fixtures/**/*_spec.rb']
-  t.spec_opts = %w(-fs --color)
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  task(:spec) { $stderr.puts '`gem install rspec` to run specs' }
+else
+  desc "Run specs"
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb'] - FileList['spec/fixtures/**/*_spec.rb']
+    t.spec_opts = %w(-fs --color)
+  end
 end
 
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
+begin
+  require 'rake/gempackagetask'
+rescue LoadError
+  task(:gem) { $stderr.puts '`gem install rake` to package gems' }
+else
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.gem_spec = spec
+  end
 end
 
 desc "install the gem locally"
@@ -45,4 +54,4 @@ task :make_spec do
   File.open("#{spec.name}.gemspec", "w") do |file|
     file.puts spec.to_ruby
   end
-end
+end

data/lib/bundler.rb

@@ -11,12 +11,11 @@ require "bundler/source"
 require "bundler/finder"
 require "bundler/gem_ext"
 require "bundler/resolver"
-require "bundler/manifest_file"
-require "bundler/manifest"
+require "bundler/environment"
 require "bundler/dsl"
 require "bundler/cli"
 require "bundler/repository"
-require "bundler/runtime/dependency"
+require "bundler/dependency"
 
 module Bundler
   VERSION = "0.5.0"

data/lib/bundler/cli.rb

@@ -23,15 +23,15 @@ module Bundler
 
     def initialize(options)
       @options = options
-      @manifest_file = Bundler::ManifestFile.load(@options[:manifest])
+      @manifest = Bundler::Environment.load(@options[:manifest])
     end
 
     def bundle
-      @manifest_file.install(@options[:update])
+      @manifest.install(@options[:update])
     end
 
     def exec
-      @manifest_file.setup_environment
+      @manifest.setup_environment
       # w0t?
       super(*@options[:args])
     end

data/lib/bundler/{runtime/dependency.rb → dependency.rb}

@@ -12,8 +12,8 @@ module Bundler
       @name       = name
       @version    = options["version"] || ">= 0"
       @require_as = Array(options["require_as"] || name)
-      @only       = Array(options["only"]).map {|e| e.to_s } if options["only"]
-      @except     = Array(options["except"]).map {|e| e.to_s } if options["except"]
+      @only       = options["only"]
+      @except     = options["except"]
       @block      = block
 
       if (@only && @only.include?("rubygems")) || (@except && @except.include?("rubygems"))
@@ -33,11 +33,11 @@ module Bundler
       to_gem_dependency.to_s
     end
 
-    def require(environment)
+    def require_env(environment)
       return unless in?(environment)
 
       @require_as.each do |file|
-        super(file)
+        require file
       end
 
       @block.call if @block

data/lib/bundler/dsl.rb

@@ -1,61 +1,109 @@
 module Bundler
   class ManifestFileNotFound < StandardError; end
 
-  class ManifestBuilder
-    def self.build(manifest_file, string)
-      builder = new(manifest_file)
-      builder.instance_eval(string)
-      builder
-    end
-
-    def self.load(manifest_file, filename)
-      unless File.exist?(filename)
-        raise ManifestFileNotFound, "#{filename.inspect} does not exist"
-      end
-      string = File.read(filename)
-      build(manifest_file, string)
-    end
-
-    def initialize(manifest_file)
-      @manifest_file  = manifest_file
+  class Dsl
+    def initialize(environment)
+      @environment = environment
+      @sources = Hash.new { |h,k| h[k] = {} }
     end
 
     def bundle_path(path)
       path = Pathname.new(path)
-      @manifest_file.gem_path = (path.relative? ?
-        @manifest_file.root.join(path) : path).expand_path
+      @environment.gem_path = (path.relative? ?
+        @environment.root.join(path) : path).expand_path
     end
 
     def bin_path(path)
       path = Pathname.new(path)
-      @manifest_file.bindir = (path.relative? ?
-        @manifest_file.root.join(path) : path).expand_path
+      @environment.bindir = (path.relative? ?
+        @environment.root.join(path) : path).expand_path
     end
 
     def disable_rubygems
-      @manifest_file.rubygems = false
+      @environment.rubygems = false
     end
 
     def disable_system_gems
-      @manifest_file.system_gems = false
+      @environment.system_gems = false
     end
 
     def source(source)
-      source = Source.new(source)
-      unless @manifest_file.sources.include?(source)
-        @manifest_file.add_source(source)
+      source = GemSource.new(:uri => source)
+      unless @environment.sources.include?(source)
+        @environment.add_source(source)
       end
     end
 
+    def only(env)
+      old, @only = @only, _combine_onlys(env)
+      yield
+      @only = old
+    end
+
+    def except(env)
+      old, @except = @except, _combine_excepts(env)
+      yield
+      @except = old
+    end
+
     def clear_sources
-      @manifest_file.clear_sources
+      @environment.clear_sources
     end
 
     def gem(name, *args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       version = args.last
 
-      @manifest_file.dependencies << Dependency.new(name, options.merge(:version => version))
+      options[:only] = _combine_onlys(options[:only] || options["only"])
+      options[:except] = _combine_excepts(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
+      end
+
+      @environment.dependencies << dep
+    end
+
+  private
+
+    def _combine_onlys(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)
+      return @except unless except
+      except = [except].flatten.compact.uniq.map { |o| o.to_s }
+      except |= @except if @except
+      except
     end
   end
 end

data/lib/bundler/environment.rb

@@ -0,0 +1,115 @@
+require "rubygems/source_index"
+
+module Bundler
+  class DefaultManifestNotFound < StandardError; end
+
+  class Environment
+    attr_reader :filename, :dependencies
+    attr_accessor :rubygems, :system_gems, :gem_path, :bindir
+
+    def self.load(gemfile = nil)
+      gemfile = gemfile ? Pathname.new(gemfile) : default_manifest_file
+
+      unless gemfile.file?
+        raise ManifestFileNotFound, "#{filename.inspect} does not exist"
+      end
+
+      new(gemfile)
+    end
+
+    def self.default_manifest_file
+      current = Pathname.new(Dir.pwd)
+
+      until current.root?
+        filename = current.join("Gemfile")
+        return filename if filename.exist?
+        current = current.parent
+      end
+
+      raise DefaultManifestNotFound
+    end
+
+    def initialize(filename) #, sources, dependencies, bindir, path, rubygems, system_gems)
+      @filename         = filename
+      @default_sources  = [GemSource.new(:uri => "http://gems.rubyforge.org")]
+      @sources          = []
+      @priority_sources = []
+      @dependencies     = []
+      @rubygems         = true
+      @system_gems      = true
+
+      # Evaluate the Gemfile
+      builder = Dsl.new(self)
+      builder.instance_eval(File.read(filename))
+    end
+
+    def install(update = false)
+      begin
+        tmp_path = filename.dirname.join(".tmp")
+        FileUtils.mkdir_p(tmp_path)
+        sources.each { |s| s.tmp_path = tmp_path }
+        repository.install(gem_dependencies, sources,
+          :rubygems    => rubygems,
+          :system_gems => system_gems,
+          :manifest    => filename,
+          :update      => update
+        )
+      ensure
+        FileUtils.rm_rf(tmp_path)
+      end
+      Bundler.logger.info "Done."
+    end
+
+    def setup_environment
+      unless system_gems
+        ENV["GEM_HOME"] = gem_path
+        ENV["GEM_PATH"] = gem_path
+      end
+      ENV["PATH"]     = "#{bindir}:#{ENV["PATH"]}"
+      ENV["RUBYOPT"]  = "-r#{gem_path}/environment #{ENV["RUBYOPT"]}"
+    end
+
+    def require_env(env = nil)
+      dependencies.each { |d| d.require_env(env) }
+    end
+
+    def root
+      filename.parent
+    end
+
+    def gem_path
+      @gem_path ||= root.join("vendor", "gems")
+    end
+
+    def bindir
+      @bindir ||= root.join("bin")
+    end
+
+    def sources
+      @priority_sources + @sources + @default_sources
+    end
+
+    def add_source(source)
+      @sources << source
+    end
+
+    def add_priority_source(source)
+      @priority_sources << source
+    end
+
+    def clear_sources
+      @sources.clear
+      @default_sources.clear
+    end
+
+  private
+
+    def repository
+      @repository ||= Repository.new(gem_path, bindir)
+    end
+
+    def gem_dependencies
+      @gem_dependencies ||= dependencies.map { |d| d.to_gem_dependency }
+    end
+  end
+end

data/lib/bundler/gem_bundle.rb

@@ -2,7 +2,7 @@ module Bundler
   class GemBundle < Array
     def download(repository)
       sort_by {|s| s.full_name.downcase }.each do |spec|
-        repository.download(spec)
+        spec.source.download(spec, repository)
       end
 
       self

data/lib/bundler/gem_ext.rb

@@ -9,16 +9,17 @@ module Gem
   end
 
   class Specification
-    attribute :source
-
-    def source=(source)
-      source = Bundler::Source.new(source) unless source.is_a?(Bundler::Source)
-      @source = source
-    end
+    attr_accessor :source
+    attr_accessor :location
 
     # Hack to fix github's strange marshal file
     def specification_version
       @specification_version && @specification_version.to_i
     end
+
+    alias full_gem_path_without_location full_gem_path
+    def full_gem_path
+      @location ? @location : full_gem_path_without_location
+    end
   end
 end

data/lib/bundler/repository.rb

@@ -1,116 +1,151 @@
+require "bundler/repository/gem_repository"
+require "bundler/repository/directory_repository"
+
 module Bundler
   class InvalidRepository < StandardError ; end
 
   class Repository
-
     attr_reader :path
 
-    def initialize(path, bindir = nil)
+    def initialize(path, bindir)
+      FileUtils.mkdir_p(path)
+
       @path   = Pathname.new(path)
-      @bindir = Pathname.new(bindir) || @path.join("bin")
-      unless valid?
-        raise InvalidRepository, "'#{path}' is not a valid gem repository"
+      @bindir = Pathname.new(bindir)
+
+      @repos = {
+        :gem       => Gems.new(@path, @bindir),
+        :directory => Directory.new(@path.join("dirs"), @bindir)
+      }
+    end
+
+    def install(dependencies, sources, options = {})
+      if options[:update] || !satisfies?(dependencies)
+        fetch(dependencies, sources)
+        expand(options)
+      else
+        # Remove any gems that are still around if the Gemfile changed without
+        # requiring new gems to be download (e.g. a line in the Gemfile was
+        # removed)
+        cleanup(Resolver.resolve(dependencies, [source_index]))
       end
+      configure(options)
+      sync
     end
 
-    # Returns the source index for all gems installed in the
-    # repository
-    def source_index
-      Gem::SourceIndex.from_gems_in(@path.join("specifications"))
+    def gems
+      gems = []
+      each_repo do |repo|
+        gems.concat repo.gems
+      end
+      gems
     end
 
-    def valid?
-      (Dir[@path.join("*")] - Dir[@path.join("{cache,doc,gems,bundler,environment.rb,specifications}")]).empty?
+    def satisfies?(dependencies)
+      index = source_index
+      dependencies.all? { |dep| index.search(dep).size > 0 }
     end
 
-    def download(spec)
-      FileUtils.mkdir_p(@path)
+    def source_index
+      index = Gem::SourceIndex.new
 
-      unless @path.join("cache", "#{spec.full_name}.gem").file?
-        spec.source.download(spec, @path)
+      each_repo do |repo|
+        index.gems.merge!(repo.source_index.gems)
       end
+
+      index
     end
 
-    # Checks whether a gem is installed
-    def install_cached_gems(options = {})
-      cached_gems.each do |name, version|
-        unless installed?(name, version)
-          install_cached_gem(name, version, options)
-        end
-      end
+    def add_spec(type, spec)
+      @repos[type].add_spec(spec)
     end
 
-    def install_cached_gem(name, version, options = {})
-      cached_gem = cache_path.join("#{name}-#{version}.gem")
-      # TODO: Add a warning if cached_gem is not a file
-      if cached_gem.file?
-        Bundler.logger.info "Installing #{name}-#{version}.gem"
-        installer = Gem::Installer.new(cached_gem.to_s, options.merge(
-          :install_dir         => @path,
-          :ignore_dependencies => true,
-          :env_shebang         => true,
-          :wrappers            => true
-        ))
-        installer.install
-      end
+    def download_path_for(type)
+      @repos[type].download_path_for
     end
 
-    def cleanup(gems)
-      glob = gems.map { |g| g.full_name }.join(',')
-      base = path.join("{cache,specifications,gems}")
+  private
 
-      (Dir[base.join("*")] - Dir[base.join("{#{glob}}{.gemspec,.gem,}")]).each do |file|
-        if File.basename(file) =~ /\.gem$/
-          name = File.basename(file, '.gem')
-          Bundler.logger.info "Deleting gem: #{name}"
-        end
-        FileUtils.rm_rf(file)
+    def cleanup(bundle)
+      each_repo do |repo|
+        repo.cleanup(bundle)
       end
+    end
 
-      glob = gems.map { |g| g.executables }.flatten.join(',')
-      (Dir[@bindir.join("*")] - Dir[@bindir.join("{#{glob}}")]).each do |file|
-        Bundler.logger.info "Deleting bin file: #{File.basename(file)}"
-        FileUtils.rm_rf(file)
+    def each_repo
+      @repos.each do |k, repo|
+        yield repo
       end
     end
 
-  private
-
-    def cache_path
-      @path.join("cache")
+    def fetch(dependencies, sources)
+      bundle = Resolver.resolve(dependencies, sources)
+      # Cleanup here to remove any gems that could cause problem in the expansion
+      # phase
+      #
+      # TODO: Try to avoid double cleanup
+      cleanup(bundle)
+      bundle.download(self)
     end
 
-    def cache_files
-      Dir[cache_path.join("*.gem")]
-    end
+    def sync
+      glob = gems.map { |g| g.executables }.flatten.join(',')
 
-    def cached_gems
-      cache_files.map do |f|
-        full_name = File.basename(f).gsub(/\.gem$/, '')
-        full_name.split(/-(?=[^-]+$)/)
+      (Dir[@bindir.join("*")] - Dir[@bindir.join("{#{glob}}")]).each do |file|
+        Bundler.logger.info "Deleting bin file: #{File.basename(file)}"
+        FileUtils.rm_rf(file)
       end
     end
 
-    def spec_path
-      @path.join("specifications")
+    def expand(options)
+      each_repo do |repo|
+        repo.expand(options)
+      end
     end
 
-    def spec_files
-      Dir[spec_path.join("*.gemspec")]
+    def configure(options)
+      generate_environment(options)
     end
 
-    def gem_path
-      @path.join("gems")
-    end
+    def generate_environment(options)
+      FileUtils.mkdir_p(path)
 
-    def gems
-      Dir[gem_path.join("*")]
+      specs      = gems
+      load_paths = load_paths_for_specs(specs)
+      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"))
+        erb = ERB.new(template, nil, '-')
+        file.puts erb.result(binding)
+      end
     end
 
-    def installed?(name, version)
-      spec_files.any? { |g| File.basename(g) == "#{name}-#{version}.gemspec" } &&
-        gems.any? { |g| File.basename(g) == "#{name}-#{version}" }
+    def load_paths_for_specs(specs)
+      load_paths = []
+      specs.each do |spec|
+        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
+        spec.require_paths.each do |path|
+          load_paths << gem_path.join(path).relative_path_from(@path).to_s
+        end
+      end
+      load_paths
     end
 
+    def require_code(file, dep)
+      constraint = case
+      when dep.only   then %{ if #{dep.only.inspect}.include?(env)}
+      when dep.except then %{ unless #{dep.except.inspect}.include?(env)}
+      end
+      "require #{file.inspect}#{constraint}"
+    end
   end
 end