bundler08 0.8.2

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,284 @@
+## Bundler : A gem to bundle gems
+
+    Github:       http://github.com/wycats/bundler
+    Mailing list: http://groups.google.com/group/ruby-bundler
+    IRC:          #carlhuda on freenode
+
+## 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.
+
+## Installation
+
+Bundler has no dependencies. Just clone the git repository and install the gem
+with the following rake task:
+
+    rake install
+
+You can also install the gem with
+
+    gem install bundler
+
+## 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 require that gem in the "testing"
+    # environment. :except is also a valid option to specify environment
+    # restrictions.
+    gem "rspec", :only => :testing
+
+    # Specify a dependency, but specify that it is already present and expanded
+    # at vendor/rspec. Bundler will treat rspec as though it was the rspec gem
+    # for the purpose of gem resolution: if another gem depends on a version
+    # of rspec satisfied by "1.1.6", it will be used.
+    #
+    # If a gemspec is found in the directory, it will be used to specify load
+    # paths and supply additional dependencies.
+    #
+    # Bundler will also recursively search for *.gemspec, and assume that
+    # gemspecs it finds represent gems that are rooted in the same directory
+    # the gemspec is found in.
+    gem "rspec", "1.1.6", :vendored_at => "vendor/rspec"
+
+    # You can also control what will happen when you run Bundler.require_env
+    # by using the :require_as option, as per the next two examples.
+
+    # Don't auto-require this gem.
+    gem "rspec-rails", "1.2.9", :require_as => nil
+
+    # Require something other than the default.
+    gem "yajl-ruby", "0.6.7", :require_as => "yajl/json_gem"
+
+    # Works exactly like :vendored_at, but first downloads the repo from
+    # git and handles stashing the files for you. As with :vendored_at,
+    # Bundler will automatically use *.gemspec files in the root or anywhere
+    # in the repository.
+    gem "rails", "3.0.pre", :git => "git://github.com/rails/rails.git"
+
+    # 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
+
+### Gem Resolution
+
+One of the most important things that the bundler does is do a
+dependency resolution on the full list of gems that you specify, all
+at once. This differs from the one-at-a-time dependency resolution that
+Rubygems does, which can result in the following problem:
+
+    # On my system:
+    #   activesupport 3.0.pre
+    #   activesupport 2.3.4
+    #   activemerchant 1.4.2
+    #   rails 2.3.4
+    #
+    # activemerchant 1.4.2 depends on activesupport >= 2.3.2
+
+    gem "activemerchant", "1.4.2"
+    # results in activating activemerchant, as well as
+    # activesupport 3.0.pre, since it is >= 2.3.2
+
+    gem "rails", "2.3.4"
+    # results in:
+    #   can't activate activesupport (= 2.3.4, runtime)
+    #   for ["rails-2.3.4"], already activated
+    #   activesupport-3.0.pre for ["activemerchant-1.4.2"]
+
+This is because activemerchant has a broader dependency, which results
+in the activation of a version of activesupport that does not satisfy
+a more narrow dependency.
+
+Bundler solves this problem by evaluating all dependencies at once,
+so it can detect that all gems *together* require activesupport "2.3.4".
+
+### 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, resolve 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.
+
+### Remote deploys
+
+When you run `gem bundle`, the following steps occur:
+
+1. Gemfile is read in
+2. The gems specified in the Gemfile are resolved against the gems
+   already in your bundle. If the dependencies resolve, skip to step 5.
+3. If the dependencies in your Gemfile cannot be fully resolved
+   against the gems already in the bundle, the metadata for each
+   source is fetched.
+4. The gems in the Gemfile are resolved against the full list of
+   available gems in all sources, and the resulting gems are downloaded
+5. Each gem that has been downloaded but not yet expanded is expanded
+   into the local directory. This expansion process also installs
+   native gems.
+
+As you can see, if you run gem bundle twice in a row, it will do nothing the
+second time, since the gems obviously resolve against the installed gems,
+and they are all expanded.
+
+This also means that if you run `gem bundle`, and .gitignore the expanded
+copies, leaving only the cached `.gem` files, you can run `gem bundle` again
+on the remote system, and it will only expand out the gems (but not
+resolve or download `.gem` files). This also means that native gems
+will be compiled for the target platform without requiring that the
+`.gem` file itself be downloaded from a remote gem server.
+
+Assuming a Rails app with Bundler's standard setup, add something like
+this to your top-level `.gitignore` to only keep the cache:
+
+    bin/*
+    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
+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
+
+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]/gems/environment.rb`. For example:
+
+    ruby -r vendor/gems/environment.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/preinitializer.rb`, add the following line:
+
+    require "#{RAILS_ROOT}/vendor/gems/environment"
+
+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 rubygems 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.
+
+This is different from the `disable_system_gems` option, which uses the rubygems
+library, but prevents system gems from being loaded; only gems that are bundled
+will be available to your application. This option guarantees that dependencies
+of your application will be available to a remote system.
+
+## 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
+at:
+
+    http://github.com/wycats/bundler/issues/

data/Rakefile

@@ -0,0 +1,81 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+require 'rubygems/specification'
+require 'bundler08'
+require 'date'
+
+spec = Gem::Specification.new do |s|
+  s.name    = "bundler08"
+  s.version = Bundler::VERSION
+  s.authors = ["Yehuda Katz", "Carl Lerche"]
+  s.email   = ["wycats@gmail.com", "clerche@engineyard.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.required_rubygems_version = ">= 1.3.5"
+
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.markdown Rakefile) + Dir.glob("lib/**/*")
+end
+
+task :default => :spec
+
+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)
+    t.warning = true
+  end
+end
+
+namespace :spec do
+  file "tmp/rg_deps" do
+    repo = File.dirname(__FILE__) + '/tmp/rg_deps'
+    FileUtils.mkdir_p(repo)
+    p repo
+    ENV['GEM_HOME'], ENV['GEM_PATH'] = repo, repo
+    system "gem install builder --no-rdoc --no-ri"
+  end
+
+  desc "Do all setup needed to run the specs"
+  task :setup => "tmp/rg_deps"
+
+  desc "Mount a ramdisk at ./tmp for faster specs"
+  task :ramdisk do
+    sh 'diskutil erasevolume HFS+ "tmpbundler" `hdiutil attach -nomount ram://116543`'
+    File.symlink "/Volumes/tmpbundler", File.expand_path('../tmp', __FILE__)
+  end
+end
+
+spec_file = "#{spec.name}.gemspec"
+desc "Create #{spec_file}"
+file spec_file => "Rakefile" do
+  File.open(spec_file, "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+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
+  task :gem => spec_file
+end
+
+desc "install the gem locally"
+task :install => :package do
+  sh %{gem install pkg/#{spec.name}-#{spec.version}}
+end

data/lib/bundler08.rb

@@ -0,0 +1,49 @@
+require 'pathname'
+require 'logger'
+require 'set'
+require 'erb'
+# Required elements of rubygems
+require "rubygems/remote_fetcher"
+require "rubygems/installer"
+
+require "bundler08/gem_bundle"
+require "bundler08/source"
+require "bundler08/finder"
+require "bundler08/gem_ext"
+require "bundler08/resolver"
+require "bundler08/environment"
+require "bundler08/dsl"
+require "bundler08/cli"
+require "bundler08/bundle"
+require "bundler08/dependency"
+require "bundler08/remote_specification"
+
+module Bundler
+  VERSION = "0.8.2"
+
+  class << self
+    attr_writer :logger, :mode
+
+    def logger
+      @logger ||= begin
+        logger = Logger.new(STDOUT, Logger::INFO)
+        logger.formatter = proc {|_,_,_,msg| "#{msg}\n" }
+        logger
+      end
+    end
+
+    def local?
+      @mode == :local
+    end
+
+    def writable?
+      @mode != :readonly
+    end
+
+    def remote?
+      @mode == :readwrite
+    end
+  end
+
+  self.mode = :readonly
+end

data/lib/bundler08/bundle.rb

@@ -0,0 +1,314 @@
+module Bundler
+  class InvalidRepository < StandardError ; end
+
+  class Bundle
+    attr_reader :gemfile, :environment
+
+    def self.load(gemfile = nil)
+      gemfile = Pathname.new(gemfile || default_gemfile).expand_path
+
+      unless gemfile.file?
+        raise ManifestFileNotFound, "Manifest file not found: #{gemfile.to_s.inspect}"
+      end
+
+      new(gemfile)
+    end
+
+    def self.default_gemfile
+      current = Pathname.new(Dir.pwd)
+
+      until current.root?
+        filename = current.join("Gemfile")
+        return filename if filename.exist?
+        current = current.parent
+      end
+
+      raise DefaultManifestNotFound
+    end
+
+    # TODO: passing in the filename is not good
+    def initialize(gemfile)
+      @gemfile = gemfile
+      @environment = Environment.new(self)
+      Dsl.evaluate(gemfile, self, @environment)
+
+      # path   = env.gem_path
+
+      FileUtils.mkdir_p(gem_path)
+
+      @cache_path = gem_path.join('cache')
+      @cache = GemDirectorySource.new(self, :location => @cache_path)
+
+      @specs_path = gem_path.join('specifications')
+      @gems_path  = gem_path.join('gems')
+    end
+
+    def root
+      gemfile.parent
+    end
+
+    def path
+      @path ||= root.join("vendor/gems")
+    end
+
+    def path=(path)
+      @path = (path.relative? ? root.join(path) : path).expand_path
+    end
+
+    def gem_path
+      path.join("#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}")
+    end
+
+    def bindir
+      @bindir ||= root.join("bin")
+    end
+
+    def bindir=(path)
+      @bindir = (path.relative? ? root.join(path) : path).expand_path
+    end
+
+    def install(options = {})
+      dependencies = @environment.dependencies
+      sources      = @environment.sources
+
+      # ========== from env
+      if only_envs = options[:only]
+        dependencies.reject! { |d| !only_envs.any? {|env| d.in?(env) } }
+      end
+      # ==========
+
+      # Check to see whether the existing cache meets all the requirements
+      begin
+        valid = nil
+        # valid = Resolver.resolve(dependencies, [source_index], source_requirements)
+      rescue Bundler::GemNotFound
+      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)
+        download(bundle, options)
+        do_install(bundle, options)
+        valid = bundle
+      end
+
+      generate_bins(valid, options)
+      cleanup(valid, options)
+      configure(valid, options)
+
+      Bundler.logger.info "Done."
+    end
+
+    def cache(*gemfiles)
+      FileUtils.mkdir_p(@cache_path)
+      gemfiles.each do |gemfile|
+        Bundler.logger.info "Caching: #{File.basename(gemfile)}"
+        FileUtils.cp(gemfile, @cache_path)
+      end
+    end
+
+    def list_outdated(options={})
+      outdated_gems = source_index.outdated.sort
+
+      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 prune(options = {})
+      dependencies, sources = @environment.dependencies, @environment.sources
+
+      sources = only_local(sources)
+      bundle = Resolver.resolve(dependencies, [@cache] + sources)
+      @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 @cache_path.join("#{spec.full_name}.gem")
+          end
+        end
+      end
+    end
+
+    def list(options = {})
+      Bundler.logger.info "Currently bundled gems:"
+      gems.each do |spec|
+        Bundler.logger.info " * #{spec.name} (#{spec.version})"
+      end
+    end
+
+    def gems
+      source_index.gems.values
+    end
+
+    def source_index
+      index = Gem::SourceIndex.from_gems_in(@specs_path)
+      index.each { |n, spec| spec.loaded_from = @specs_path.join("#{spec.full_name}.gemspec") }
+      index
+    end
+
+    def download_path_for(type)
+      @repos[type].download_path_for
+    end
+
+    def setup_environment
+      unless @environment.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
+
+  private
+
+    def only_local(sources)
+      sources.select { |s| s.local? }
+    end
+
+    def download(bundle, options)
+      bundle.sort_by {|s| s.full_name.downcase }.each do |spec|
+        next if spec.no_bundle?
+        spec.source.download(spec)
+      end
+    end
+
+    def do_install(bundle, options)
+      bundle.each do |spec|
+        next if spec.no_bundle?
+        spec.loaded_from = @specs_path.join("#{spec.full_name}.gemspec")
+        # Do nothing if the gem is already expanded
+        next if @gems_path.join(spec.full_name).directory?
+
+        case spec.source
+        when GemSource, GemDirectorySource, SystemGemSource
+          expand_gemfile(spec, options)
+        else
+          expand_vendored_gem(spec, options)
+        end
+      end
+    end
+
+    def generate_bins(bundle, options)
+      bundle.each do |spec|
+        next if spec.no_bundle?
+        # HAX -- Generate the bin
+        bin_dir = bindir
+        path    = gem_path
+        gems_path = @gems_path
+        installer = Gem::Installer.allocate
+        installer.instance_eval do
+          @spec     = spec
+          @bin_dir  = bin_dir
+          @gem_dir  = gems_path.join(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 = @cache_path.join("#{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         => gem_path,
+        :ignore_dependencies => true,
+        :env_shebang         => true,
+        :wrappers            => true,
+        :bin_dir             => bindir
+      ))
+      installer.install
+    rescue Gem::InstallError
+      cleanup_spec(spec)
+      raise
+    ensure
+      Gem::Command.build_args = []
+    end
+
+    def expand_vendored_gem(spec, options)
+      add_spec(spec)
+      FileUtils.mkdir_p(@gems_path)
+      File.symlink(spec.location, @gems_path.join(spec.full_name))
+    end
+
+    def add_spec(spec)
+      destination = @specs_path
+      destination.mkdir unless destination.exist?
+
+      File.open(destination.join("#{spec.full_name}.gemspec"), 'w') do |f|
+        f.puts spec.to_ruby
+      end
+    end
+
+    def cleanup(valid, options)
+      to_delete = gems
+      to_delete.delete_if do |spec|
+        valid.any? { |other| spec.name == other.name && spec.version == other.version }
+      end
+
+      valid_executables = valid.map { |s| s.executables }.flatten.compact
+
+      to_delete.each do |spec|
+        Bundler.logger.info "Deleting gem: #{spec.name} (#{spec.version})"
+        cleanup_spec(spec)
+        # Cleanup the bin directory
+        spec.executables.each do |bin|
+          next if valid_executables.include?(bin)
+          Bundler.logger.info "Deleting bin file: #{bin}"
+          FileUtils.rm_rf(bindir.join(bin))
+        end
+      end
+    end
+
+    def cleanup_spec(spec)
+      FileUtils.rm_rf(@specs_path.join("#{spec.full_name}.gemspec"))
+      FileUtils.rm_rf(@gems_path.join(spec.full_name))
+    end
+
+    def expand(options)
+      each_repo do |repo|
+        repo.expand(options)
+      end
+    end
+
+    def configure(specs, options)
+      FileUtils.mkdir_p(gem_path)
+
+      File.open(gem_path.join("environment.rb"), "w") do |file|
+        file.puts @environment.environment_rb(specs, options)
+      end
+
+      generate_environment_picker
+    end
+
+    def generate_environment_picker
+      FileUtils.cp("#{File.dirname(__FILE__)}/templates/environment_picker.erb", path.join("environment.rb"))
+    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