bundler 0.3.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Engine Yard
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,156 @@
+## Bundler : A gem to bundle gems
+
+    Github:       http://github.com/wycats/bundler
+    Mailing list: http://groups.google.com/group/ruby-bundler
+
+## Intro
+
+Bundler is a tool that manages gem dependencies for your ruby application. It
+takes a gem manifest file and is able to fetch, download, and install the gems
+and all child dependencies specified in this manifest. It can manage any update
+to the gem manifest file and update the bundled gems accordingly. It also lets
+you run any ruby code in context of the bundled gem environment.
+
+## Disclaimer
+
+This project is under rapid development. It is usable today, but there will be
+many changes in the near future, including to the Gemfile DSL. We will bump up
+versions with changes though. We greatly appreciate feedback.
+
+## Installation
+
+Bundler has no dependencies. Just clone the git repository and install the gem
+with the following rake task:
+
+    rake install
+
+## Usage
+
+Bundler requires a gem manifest file to be created. This should be a file named
+`Gemfile` located in the root directory of your application. After the manifest
+has been created, in your shell, cd into your application's directory and run
+`gem bundle`. This will start the bundling process.
+
+### Manifest file
+
+This is where you specify all of your application's dependencies. By default
+this should be in a file named `Gemfile` located in your application's root
+directory. The following is an example of a potential `Gemfile`. For more
+information, please refer to Bundler::ManifestBuilder.
+
+    # Specify a dependency on rails. When the bundler downloads gems,
+    # it will download rails as well as all of rails' dependencies (such as
+    # activerecord, actionpack, etc...)
+    #
+    # At least one dependency must be specified
+    gem "rails"
+
+    # Specify a dependency on rack v.1.0.0. The version is optional. If present,
+    # it can be specified the same way as with rubygems' #gem method.
+    gem "rack", "1.0.0"
+
+    # Specify a dependency rspec, but only activate that gem in the "testing"
+    # environment (read more about environments later). :except is also a valid
+    # option to specify environment restrictions.
+    gem "rspec", :only => :testing
+
+    # Add http://gems.github.com as a source that the bundler will use
+    # to find gems listed in the manifest. By default,
+    # http://gems.rubyforge.org is already added to the list.
+    #
+    # This is an optional setting.
+    source "http://gems.github.com"
+
+    # Specify where the bundled gems should be stashed. This directory will
+    # be a gem repository where all gems are downloaded to and installed to.
+    #
+    # This is an optional setting.
+    # The default is: vendor/gems
+    bundle_path "my/bundled/gems"
+
+    # Specify where gem executables should be copied to.
+    #
+    # This is an optional setting.
+    # The default is: bin
+    bin_path "my/executables"
+
+    # Specify that rubygems should be completely disabled. This means that it
+    # will be impossible to require it and that available gems will be
+    # limited exclusively to gems that have been bundled.
+    #
+    # The default is to automatically require rubygems. There is also a
+    # `disable_system_gems` option that will limit available rubygems to
+    # the ones that have been bundled.
+    disable_rubygems
+
+### Running Bundler
+
+Once a manifest file has been created, the only thing that needs to be done
+is to run the `gem bundle` command anywhere in your application. The script
+will load the manifest file, resole all the dependencies, download all
+needed gems, and install them into the specified directory.
+
+Every time an update is made to the manifest file, run `gem bundle` again to
+get the changes installed. This will only check the remote sources if your
+currently installed gems do not satisfy the `Gemfile`. If you want to force
+checking for updates on the remote sources, use the `--update` option.
+
+### Running your application
+
+The easiest way to run your application is to start it with an executable
+copied to the specified bin directory (by default, simply bin). For example,
+if the application in question is a rack app, start it with `bin/rackup`.
+This will automatically set the gem environment correctly.
+
+Another way to run arbitrary ruby code in context of the bundled gems is to
+run it with the `gem exec` command. For example:
+
+    gem exec ruby my_ruby_script.rb
+
+Yet another way is to manually require the environment file first. This is
+located in `[bundle_path]/environments/default.rb`. For example:
+
+    ruby -r vendor/gems/environments/default.rb my_ruby_script.rb
+
+### Using Bundler with Rails today
+
+It should be possible to use Bundler with Rails today. Here are the steps
+to follow.
+
+* In your rails app, create a Gemfile and specify the gems that your
+  application depends on. Make sure to specify rails as well:
+  
+        gem "rails", "2.1.2"
+        gem "will_paginate"
+
+        # Optionally, you can disable system gems all together and only
+        # use bundled gems.
+        disable_system_gems
+
+* Run `gem bundle`
+
+* You can now use rails if you prepend `gem exec` to every call to `script/*`
+  but that isn't fun.
+
+* At the top of `config/boot.rb`, add the following line:
+
+        require File.expand_path(File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', 'environments', 'default'))
+
+In theory, this should be enough to get going.
+
+## To require rubygems or not
+
+Ideally, no gem would assume the presence of rubygems at runtime. Rubygems provides
+enough features so that this isn't necessary. However, there are a number of gems
+that require specific rubygem features.
+
+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.
+
+## Reporting bugs
+
+Please report all bugs on the github issue tracker for the project located
+at:
+
+    http://github.com/wycats/bundler/issues/

data/Rakefile

@@ -0,0 +1,46 @@
+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.3.0"
+  s.author  = "Yehuda Katz"
+  s.email   = "wycats@gmail.com"
+  s.homepage = "http://github.com/wycats/bundler"
+  s.description = s.summary = "An easy way to vendor gem dependencies"
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.markdown", "LICENSE"]
+
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.markdown Rakefile) + Dir.glob("lib/**/*")
+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)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{gem install pkg/#{spec.name}-#{spec.version}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{spec.name}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/lib/bundler.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+require 'logger'
+require 'set'
+require 'erb'
+# Required elements of rubygems
+require "rubygems/remote_fetcher"
+require "rubygems/installer"
+
+require "bundler/gem_bundle"
+require "bundler/finder"
+require "bundler/gem_ext"
+require "bundler/resolver"
+require "bundler/manifest_file"
+require "bundler/manifest"
+require "bundler/dependency"
+require "bundler/runtime"
+require "bundler/cli"
+require "bundler/repository"
+
+module Bundler
+  VERSION = "0.5.0"
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= begin
+        logger = Logger.new(STDOUT, Logger::INFO)
+        logger.formatter = proc {|_,_,_,msg| "#{msg}\n" }
+        logger
+      end
+    end
+  end
+end

data/lib/bundler/cli.rb

@@ -0,0 +1,43 @@
+require "optparse"
+
+module Bundler
+  class CLI
+    def self.run(command, options = {})
+      new(options).run(command)
+    end
+
+    def initialize(options)
+      @options = options
+      @manifest_file = Bundler::ManifestFile.load(@options[:manifest])
+    end
+
+    def bundle
+      @manifest_file.install(@options[:update])
+    end
+
+    def exec
+      @manifest_file.setup_environment
+      # w0t?
+      super(*@options[:args])
+    end
+
+    def run(command)
+
+      send(command)
+
+    rescue DefaultManifestNotFound => e
+      Bundler.logger.error "Could not find a Gemfile to use"
+      exit 2
+    rescue InvalidEnvironmentName => e
+      Bundler.logger.error "Gemfile error: #{e.message}"
+      exit
+    rescue InvalidRepository => e
+      Bundler.logger.error e.message
+      exit
+    rescue VersionConflict => e
+      Bundler.logger.error e.message
+      exit
+    end
+
+  end
+end

data/lib/bundler/commands/bundle_command.rb

@@ -0,0 +1,29 @@
+class Gem::Commands::BundleCommand < Gem::Command
+
+  def initialize
+    super('bundle', 'Create a gem bundle based on your Gemfile', {:manifest => nil, :update => false})
+
+    add_option('-m', '--manifest MANIFEST', "Specify the path to the manifest file") do |manifest, options|
+      options[:manifest] = Pathname.new(manifest)
+    end
+
+    add_option('-u', '--update', "Force a remote check for newer gems") do
+      options[:update] = true
+    end
+  end
+
+  def usage
+    "#{program_name}"
+  end
+
+  def description # :nodoc:
+    <<-EOF
+Bundle stuff
+    EOF
+  end
+
+  def execute
+    Bundler::CLI.run(:bundle, options)
+  end
+
+end

data/lib/bundler/commands/exec_command.rb

@@ -0,0 +1,29 @@
+class Gem::Commands::ExecCommand < Gem::Command
+
+  def initialize
+    super('exec', 'Run a command in context of a gem bundle', {:manifest => nil})
+
+    add_option('-m', '--manifest MANIFEST', "Specify the path to the manifest file") do |manifest, options|
+      options[:manifest] = Pathname.new(manifest)
+    end
+  end
+
+  def usage
+    "#{program_name} COMMAND"
+  end
+
+  def arguments # :nodoc:
+    "COMMAND  command to run in context of the gem bundle"
+  end
+
+  def description # :nodoc:
+    <<-EOF.gsub('      ', '')
+      Run in context of a bundle
+    EOF
+  end  
+
+  def execute
+    Bundler::CLI.run(:exec, options)
+  end
+
+end

data/lib/bundler/dependency.rb

@@ -0,0 +1,45 @@
+module Bundler
+  class InvalidEnvironmentName < StandardError; end
+
+  class Dependency
+    attr_reader :name, :version, :require_as, :only, :except
+
+    def initialize(name, options = {})
+      options.each do |k, v|
+        options[k.to_s] = v
+      end
+
+      @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"]
+
+      if (@only && @only.include?("rubygems")) || (@except && @except.include?("rubygems"))
+        raise InvalidEnvironmentName, "'rubygems' is not a valid environment name"
+      end
+    end
+
+    def in?(environment)
+      environment = environment.to_s
+
+      return false unless !@only || @only.include?(environment)
+      return false if @except && @except.include?(environment)
+      true
+    end
+
+    def to_s
+      to_gem_dependency.to_s
+    end
+
+    def to_gem_dependency
+      @gem_dep ||= Gem::Dependency.new(name, version)
+    end
+
+    def ==(o)
+      [name, version, require_as, only, except] ==
+        [o.name, o.version, o.require_as, o.only, o.except]
+    end
+
+  end
+end

data/lib/bundler/finder.rb

@@ -0,0 +1,89 @@
+module Bundler
+  # Finder behaves like a rubygems source index in that it responds
+  # to #search. It also resolves a list of dependencies finding the
+  # best possible configuration of gems that satisifes all requirements
+  # without causing any gem activation errors.
+  class Finder
+
+    # Takes an array of gem sources and fetches the full index of
+    # gems from each one. It then combines the indexes together keeping
+    # track of the original source so that any resolved gem can be
+    # fetched from the correct source.
+    #
+    # ==== Parameters
+    # *sources<String>:: URI pointing to the gem repository
+    def initialize(*sources)
+      @results = {}
+      @index   = Hash.new { |h,k| h[k] = {} }
+
+      sources.each { |source| fetch(source) }
+    end
+
+    # Figures out the best possible configuration of gems that satisfies
+    # the list of passed dependencies and any child dependencies without
+    # causing any gem activation errors.
+    #
+    # ==== Parameters
+    # *dependencies<Gem::Dependency>:: The list of dependencies to resolve
+    #
+    # ==== Returns
+    # <GemBundle>,nil:: If the list of dependencies can be resolved, a
+    #   collection of gemspecs is returned. Otherwise, nil is returned.
+    def resolve(*dependencies)
+      Bundler.logger.info "Calculating dependencies..."
+
+      resolved = Resolver.resolve(dependencies, self)
+      resolved && GemBundle.new(resolved)
+    end
+
+    # Fetches the index from the remote source
+    #
+    # ==== Parameters
+    # source<String>:: URI pointing to the gem repository
+    #
+    # ==== Raises
+    # ArgumentError:: If the source is not a valid gem repository
+    def fetch(source)
+      Bundler.logger.info "Updating source: #{source}"
+
+      deflated = Gem::RemoteFetcher.fetcher.fetch_path("#{source}/Marshal.4.8.Z")
+      inflated = Gem.inflate deflated
+
+      append(Marshal.load(inflated), source)
+    rescue Gem::RemoteFetcher::FetchError => e
+      raise ArgumentError, "#{source} is not a valid source: #{e.message}"
+    end
+
+    # Adds a new gem index linked to a gem source to the over all
+    # gem index that gets searched.
+    #
+    # ==== Parameters
+    # index<Gem::SourceIndex>:: The index to append to the list
+    # source<String>:: The original source
+    def append(index, source)
+      index.gems.values.each do |spec|
+        next unless Gem::Platform.match(spec.platform)
+        spec.source = source
+        @index[spec.name][spec.version] ||= spec
+      end
+      self
+    end
+
+    # Searches for a gem that matches the dependency
+    #
+    # ==== Parameters
+    # dependency<Gem::Dependency>:: The gem dependency to search for
+    #
+    # ==== Returns
+    # [Gem::Specification]:: A collection of gem specifications
+    #   matching the search
+    def search(dependency)
+      @results[dependency.hash] ||= begin
+        possibilities = @index[dependency.name].values
+        possibilities.select do |spec|
+          dependency =~ spec
+        end.sort_by {|s| s.version }
+      end
+    end
+  end
+end

data/lib/bundler/gem_bundle.rb

@@ -0,0 +1,16 @@
+module Bundler
+  class GemBundle < Array
+    def download(directory)
+      FileUtils.mkdir_p(directory)
+
+      each do |spec|
+        unless directory.join("cache", "#{spec.full_name}.gem").file?
+          Bundler.logger.info "Downloading #{spec.full_name}.gem"
+          Gem::RemoteFetcher.fetcher.download(spec, spec.source, directory)
+        end
+      end
+
+      self
+    end
+  end
+end

data/lib/bundler/gem_ext.rb

@@ -0,0 +1,19 @@
+module Gem
+  class Installer
+    def app_script_text(bin_file_name)
+      path = @gem_home
+      template = File.read(File.join(File.dirname(__FILE__), "templates", "app_script.rb"))
+      erb = ERB.new(template)
+      erb.result(binding)
+    end
+  end
+
+  class Specification
+    attribute :source
+
+    def source=(source)
+      @source = source.is_a?(URI) ? source : URI.parse(source)
+      raise ArgumentError, "The source must be an absolute URI" unless @source.absolute?
+    end
+  end
+end

data/lib/bundler/manifest.rb

@@ -0,0 +1,136 @@
+require "rubygems/source_index"
+
+module Bundler
+  class VersionConflict < StandardError; end
+
+  class Manifest
+    attr_reader :sources, :dependencies, :path
+
+    def initialize(sources, dependencies, bindir, repository_path, rubygems, system_gems)
+      sources.map! {|s| s.is_a?(URI) ? s : URI.parse(s) }
+      @sources      = sources
+      @dependencies = dependencies
+      @bindir       = bindir
+      @repository   = Repository.new(repository_path)
+      @rubygems     = rubygems
+      @system_gems  = system_gems
+    end
+
+    def install(update)
+      fetch(update)
+      @repository.install_cached_gems(:bin_dir => @bindir || @repository.path.join("bin"))
+      cleanup_removed_gems
+      create_environment_files(@repository.path.join("environments"))
+      Bundler.logger.info "Done."
+    end
+
+    def activate(environment = "default")
+      require @repository.path.join("environments", "#{environment}.rb")
+    end
+
+    def require_all
+      dependencies.each do |dep|
+        dep.require_as.each {|file| require file }
+      end
+    end
+
+    def gems_for(environment = nil)
+      deps     = dependencies
+      deps     = deps.select { |d| d.in?(environment) } if environment
+      deps     = deps.map { |d| d.to_gem_dependency }
+      Resolver.resolve(deps, @repository.source_index)
+    end
+    alias gems gems_for
+
+    def environments
+      envs = dependencies.map {|dep| Array(dep.only) + Array(dep.except) }.flatten
+      envs << "default"
+    end
+
+  private
+
+    def fetch(update)
+      return unless update || !all_gems_installed?
+
+      finder = Finder.new(*sources)
+      unless bundle = finder.resolve(*gem_dependencies)
+        gems = @dependencies.map {|d| "  #{d.to_s}" }.join("\n")
+        raise VersionConflict, "No compatible versions could be found for:\n#{gems}"
+      end
+
+      bundle.download(@repository.path)
+    end
+
+    def gem_dependencies
+      @gem_dependencies ||= dependencies.map { |d| d.to_gem_dependency }
+    end
+
+    def all_gems_installed?
+      downloaded_gems = {}
+
+      Dir[@repository.path.join("cache", "*.gem")].each do |file|
+        file =~ /\/([^\/]+)-([\d\.]+)\.gem$/
+        name, version = $1, $2
+        downloaded_gems[name] = Gem::Version.new(version)
+      end
+
+      gem_dependencies.all? do |dep|
+        downloaded_gems[dep.name] &&
+        dep.version_requirements.satisfied_by?(downloaded_gems[dep.name])
+      end
+    end
+
+    def cleanup_removed_gems
+      glob = gems.map { |g| g.full_name }.join(',')
+      base = @repository.path.join("{cache,specifications,gems}")
+
+      (Dir[base.join("*")] - Dir[base.join("{#{glob}}{.gemspec,.gem,}")]).each do |file|
+        Bundler.logger.info "Deleting gem: #{File.basename(file, ".gem")}" if File.basename(file) =~ /\.gem$/
+        FileUtils.rm_rf(file)
+      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)
+      end
+    end
+
+    def create_environment_files(path)
+      FileUtils.mkdir_p(path)
+      environments.each do |environment|
+        specs = gems_for(environment)
+        files = spec_files_for_specs(specs, path)
+        load_paths = load_paths_for_specs(specs)
+        create_environment_file(path, environment, files, load_paths)
+      end
+    end
+
+    def create_environment_file(path, environment, spec_files, load_paths)
+      File.open(path.join("#{environment}.rb"), "w") do |file|
+        template = File.read(File.join(File.dirname(__FILE__), "templates", "environment.rb"))
+        erb = ERB.new(template)
+        file.puts erb.result(binding)
+      end
+    end
+
+    def load_paths_for_specs(specs)
+      load_paths = []
+      specs.each do |spec|
+        load_paths << File.join(spec.full_gem_path, spec.bindir) if spec.bindir
+        spec.require_paths.each do |path|
+          load_paths << File.join(spec.full_gem_path, path)
+        end
+      end
+      load_paths
+    end
+
+    def spec_files_for_specs(specs, path)
+      files = {}
+      specs.each do |s|
+        files[s.name] = path.join("..", "specifications", "#{s.full_name}.gemspec").expand_path
+      end
+      files
+    end
+  end
+end

data/lib/bundler/manifest_file.rb

@@ -0,0 +1,75 @@
+module Bundler
+  class DefaultManifestNotFound < StandardError; end
+
+  class ManifestFile
+    attr_reader :sources, :dependencies
+    attr_accessor :gem_path, :bindir, :rubygems, :system_gems
+
+    def self.load(filename = nil)
+      new(filename).load
+    end
+
+    def initialize(filename)
+      @filename      = filename
+      @sources       = %w(http://gems.rubyforge.org)
+      @dependencies  = []
+      @rubygems      = true
+      @system_gems   = true
+    end
+
+    def load
+      manifest
+      self
+    end
+
+    def manifest
+      @manifest ||= load_manifest
+    end
+
+    def install(update = false)
+      manifest.install(update)
+    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}/environments/default #{ENV["RUBYOPT"]}"
+    end
+
+    def load_manifest
+      ManifestBuilder.load(self, filename)
+      Manifest.new(sources, dependencies, bindir, gem_path, rubygems, system_gems)
+    end
+
+    def gem_path
+      @gem_path ||= root.join("vendor", "gems")
+    end
+
+    def bindir
+      @bindir ||= root.join("bin")
+    end
+
+    def root
+      filename.parent
+    end
+
+    def filename
+      @filename ||= find_manifest_file
+    end
+
+    def find_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
+  end
+end

data/lib/bundler/repository.rb

@@ -0,0 +1,87 @@
+module Bundler
+  class InvalidRepository < StandardError ; end
+
+  class Repository
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = Pathname.new(path)
+      unless valid?
+        raise InvalidRepository, "'#{path}' is not a valid gem repository"
+      end
+    end
+
+    # Returns the source index for all gems installed in the
+    # repository
+    def source_index
+      Gem::SourceIndex.from_gems_in(@path.join("specifications"))
+    end
+
+    def valid?
+      (Dir[@path.join("*")] - Dir[@path.join("{cache,doc,gems,environments,specifications}")]).empty?
+    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
+    end
+
+    def install_cached_gem(name, version, options = {})
+      cached_gem = cache_path.join("#{name}-#{version}.gem")
+      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
+    end
+
+  private
+
+    def cache_path
+      @path.join("cache")
+    end
+
+    def cache_files
+      Dir[cache_path.join("*.gem")]
+    end
+
+    def cached_gems
+      cache_files.map do |f|
+        full_name = File.basename(f).gsub(/\.gem$/, '')
+        full_name.split(/-(?=[\d.]+$)/)
+      end
+    end
+
+    def spec_path
+      @path.join("specifications")
+    end
+
+    def spec_files
+      Dir[spec_path.join("*.gemspec")]
+    end
+
+    def gem_path
+      @path.join("gems")
+    end
+
+    def gems
+      Dir[gem_path.join("*")]
+    end
+
+    def installed?(name, version)
+      spec_files.any? { |g| File.basename(g) == "#{name}-#{version}.gemspec" } &&
+        gems.any? { |g| File.basename(g) == "#{name}-#{version}" }
+    end
+
+  end
+end

data/lib/bundler/resolver.rb

@@ -0,0 +1,77 @@
+# Extending Gem classes to add necessary tracking information
+module Gem
+  class Dependency
+    def required_by
+      @required_by ||= []
+    end
+  end
+  class Specification
+    def required_by
+      @required_by ||= []
+    end
+  end
+end
+
+module Bundler
+
+  class Resolver
+
+    attr_reader :errors
+
+    def self.resolve(requirements, index = Gem.source_index)
+      result = catch(:success) do
+        resolver = new(index)
+        resolver.resolve(requirements, {})
+        nil
+      end
+      result && result.values
+    end
+
+    def initialize(index)
+      @errors = {}
+      @index  = index
+    end
+
+    def resolve(reqs, activated)
+      throw :success, activated if reqs.empty?
+
+      reqs = reqs.sort_by do |req|
+        activated[req.name] ? 0 : @index.search(req).size
+      end
+
+      activated = activated.dup
+      current   = reqs.shift
+
+      if existing = activated[current.name]
+        if current.version_requirements.satisfied_by?(existing.version)
+          @errors.delete(existing.name)
+          resolve(reqs, activated)
+        else
+          @errors[existing.name] = { :gem => existing, :requirement => current }
+          parent = current.required_by.last || existing.required_by.last
+          throw parent.name
+        end
+      else
+        @index.search(current).reverse_each do |spec|
+          resolve_requirement(spec, current, reqs.dup, activated.dup)
+        end
+      end
+    end
+
+    def resolve_requirement(spec, requirement, reqs, activated)
+      spec.required_by.replace requirement.required_by
+      activated[spec.name] = spec
+
+      spec.dependencies.each do |dep|
+        next if dep.type == :development
+        dep.required_by << requirement
+        reqs << dep
+      end
+
+      catch(requirement.name) do
+        resolve(reqs, activated)
+      end
+    end
+
+  end
+end

data/lib/bundler/runtime.rb

@@ -0,0 +1,59 @@
+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
+    end
+
+    def bundle_path(path)
+      path = Pathname.new(path)
+      @manifest_file.gem_path = (path.relative? ?
+        @manifest_file.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
+    end
+
+    def disable_rubygems
+      @manifest_file.rubygems = false
+    end
+
+    def disable_system_gems
+      @manifest_file.system_gems = false
+    end
+
+    def source(source)
+      @manifest_file.sources << source
+      @manifest_file.sources.uniq!
+    end
+
+    def sources
+      @manifest_file.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))
+    end
+  end
+end

data/lib/bundler/templates/app_script.rb

@@ -0,0 +1,3 @@
+<%= shebang bin_file_name %>
+require "<%= path.join("environments", "default") %>"
+load "<%= path.join("gems", @spec.full_name, @spec.bindir, bin_file_name) %>"

data/lib/bundler/templates/environment.rb

@@ -0,0 +1,82 @@
+<% unless @system_gems %>
+ENV["GEM_HOME"] = "<%= @repository.path %>"
+ENV["GEM_PATH"] = "<%= @repository.path %>"
+<% end %>
+ENV["PATH"]     = "<%= @bindir %>:#{ENV["PATH"]}"
+ENV["RUBYOPT"]  = "-r#{__FILE__} #{ENV["RUBYOPT"]}"
+
+<% load_paths.each do |load_path| %>
+$LOAD_PATH.unshift "<%= load_path %>"
+<% end %>
+
+<% if @rubygems %>
+require "rubygems"
+
+module Bundler
+
+  @bundled_specs = {}
+  <% spec_files.each do |name, path| %>
+  @bundled_specs["<%= name %>"] = eval(File.read("<%= path %>"))
+  @bundled_specs["<%= name %>"].loaded_from = "<%= path %>"
+  <% end %>
+
+  def self.add_specs_to_loaded_specs
+    Gem.loaded_specs.merge! @bundled_specs
+    if Gem.respond_to?(:loaded_stacks)
+      @bundled_specs.keys.each { |name| Gem.loaded_stacks[name] = [] }
+    end
+  end
+
+  def self.add_specs_to_index
+    @bundled_specs.each do |name, spec|
+      Gem.source_index.add_spec spec
+    end
+  end
+
+  add_specs_to_loaded_specs
+  add_specs_to_index
+end
+
+module Gem
+  def source_index.refresh!
+    super
+    Bundler.add_specs_to_index
+  end
+end
+
+<% else %>
+
+$" << "rubygems.rb"
+module Kernel
+  def gem(*)
+    # Silently ignore calls to gem, since, in theory, everything
+    # is activated correctly already.
+  end
+end
+
+# Define all the Gem errors for gems that reference them.
+module Gem
+  def self.ruby ; <%= Gem.ruby.inspect %> ; end
+  class LoadError < ::LoadError; end
+  class Exception < RuntimeError; end
+  class CommandLineError < Exception; end
+  class DependencyError < Exception; end
+  class DependencyRemovalException < Exception; end
+  class GemNotInHomeException < Exception ; end
+  class DocumentError < Exception; end
+  class EndOfYAMLException < Exception; end
+  class FilePermissionError < Exception; end
+  class FormatException < Exception; end
+  class GemNotFoundException < Exception; end
+  class InstallError < Exception; end
+  class InvalidSpecificationException < Exception; end
+  class OperationNotSupportedError < Exception; end
+  class RemoteError < Exception; end
+  class RemoteInstallationCancelled < Exception; end
+  class RemoteInstallationSkipped < Exception; end
+  class RemoteSourceException < Exception; end
+  class VerificationError < Exception; end
+  class SystemExitException < SystemExit; end
+end
+
+<% end %>

data/lib/bundler/templates/rubygems.rb

@@ -0,0 +1,5 @@
+$:.delete File.expand_path(File.dirname(__FILE__))
+load "rubygems.rb"
+if defined?(Bundler) && Bundler.respond_to?(:rubygems_required)
+  Bundler.rubygems_required
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,7 @@
+require 'rubygems/command_manager'
+require 'bundler'
+require 'bundler/commands/bundle_command'
+require 'bundler/commands/exec_command'
+
+Gem::CommandManager.instance.register_command :bundle
+Gem::CommandManager.instance.register_command :exec

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: bundler
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Yehuda Katz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-29 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: An easy way to vendor gem dependencies
+email: wycats@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/bundler/cli.rb
+- lib/bundler/commands/bundle_command.rb
+- lib/bundler/commands/exec_command.rb
+- lib/bundler/dependency.rb
+- lib/bundler/finder.rb
+- lib/bundler/gem_bundle.rb
+- lib/bundler/gem_ext.rb
+- lib/bundler/manifest.rb
+- lib/bundler/manifest_file.rb
+- lib/bundler/repository.rb
+- lib/bundler/resolver.rb
+- lib/bundler/runtime.rb
+- lib/bundler/templates/app_script.rb
+- lib/bundler/templates/environment.rb
+- lib/bundler/templates/rubygems.rb
+- lib/bundler.rb
+- lib/rubygems_plugin.rb
+has_rdoc: true
+homepage: http://github.com/wycats/bundler
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An easy way to vendor gem dependencies
+test_files: []
+