honkster-bundler 1.1.pre

data/ISSUES.md

@@ -0,0 +1,32 @@
+# Bundler Issues
+
+## Troubleshooting
+
+Instructions for common Bundler use-cases can be found on the [Bundler documentation site](http://gembundler.com/v1.0/). Detailed information about each Bundler command, including help with common problems, can be found in the [Bundler man pages](http://gembundler.com/man/bundle.1.html).
+
+After reading the documentation, try these troubleshooting steps:
+
+    rm -rf ~/.bundle/ ~/.gem/ .bundle/ vendor/cache/ Gemfile.lock
+    bundle install
+
+## Reporting unresolved problems
+
+If you are still having problems, please report issues to the [Bundler issue tracker](http://github.com/carlhuda/bundler/issues/).
+
+Instructions that allow the Bundler team to reproduce your issue are vitally important. When you report a bug, please create a gist of the following information and include a link in your ticket:
+
+  - What version of bundler you are using
+  - What version of Ruby you are using
+  - Whether you are using RVM, and if so what version
+  - Your Gemfile
+  - Your Gemfile.lock
+  - If you are on 0.9, whether you have locked or not
+  - If you are on 1.0, the result of `bundle config`
+  - The command you ran to generate exception(s)
+  - The exception backtrace(s)
+
+If you are using Rails 2.3, please also include:
+
+  - Your boot.rb file
+  - Your preinitializer.rb file
+  - Your environment.rb file

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.md

@@ -0,0 +1,29 @@
+# Bundler: a gem to bundle gems
+
+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 bundle's gems accordingly. It also lets
+you run any ruby code in context of the bundle's gem environment.
+
+### Installation and usage
+
+See [gembundler.com](http://gembundler.com) for up-to-date installation and usage instructions.
+
+### Troubleshooting
+
+For help with common problems, see [ISSUES](http://github.com/carlhuda/bundler/blob/master/ISSUES.md).
+
+### Development
+
+To see what has changed in recent versions of bundler, see the [CHANGELOG](http://github.com/carlhuda/bundler/blob/master/CHANGELOG.md).
+
+The `master` branch contains our current progress towards version 1.1. Because of that, please submit bugfix pull requests against the `1-0-stable` branch.
+
+### Upgrading from Bundler 0.8 to 0.9 and above
+
+See [UPGRADING](http://github.com/carlhuda/bundler/blob/master/UPGRADING.md).
+
+### Other questions
+
+Feel free to chat with the Bundler core team (and many other users) on IRC in the  [#bundler](irc://irc.freenode.net/bundler) channel on Freenode, or via email on the [Bundler mailing list](http://groups.google.com/group/ruby-bundler).

data/Rakefile

@@ -0,0 +1,150 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require 'bundler/gem_helper'
+Bundler::GemHelper.install_tasks
+
+def sudo?
+  ENV['BUNDLER_SUDO_TESTS']
+end
+
+begin
+  require 'rspec/core/rake_task'
+  require 'ronn'
+
+  desc "Run specs"
+  RSpec::Core::RakeTask.new do |t|
+    t.rspec_opts = %w(-fs --color)
+    t.ruby_opts  = %w(-w)
+  end
+  task :spec => "man:build"
+
+  namespace :ci do
+    desc "Run specs without color"
+    RSpec::Core::RakeTask.new(:spec) do |t|
+      t.rspec_opts = %w(-fs)
+      t.ruby_opts  = %w(-w)
+    end
+    task :spec => "man:build"
+  end
+
+  namespace :spec do
+    desc "Run the spec suite with the sudo tests"
+    task :sudo => ["set_sudo", "clean", "spec"]
+
+    task :set_sudo do
+      ENV['BUNDLER_SUDO_TESTS'] = '1'
+    end
+
+    task :clean do
+      if sudo?
+        system "sudo rm -rf #{File.expand_path('../tmp', __FILE__)}"
+      else
+        rm_rf 'tmp'
+      end
+    end
+
+    namespace :rubygems do
+      # Rubygems 1.3.5, 1.3.6, and HEAD specs
+      rubyopt = ENV["RUBYOPT"]
+      %w(master REL_1_3_5 REL_1_3_6).each do |rg|
+        desc "Run specs with Rubygems #{rg}"
+        RSpec::Core::RakeTask.new(rg) do |t|
+          t.rspec_opts = %w(-fs --color)
+          t.ruby_opts  = %w(-w)
+        end
+
+        task "clone_rubygems_#{rg}" do
+          unless File.directory?("tmp/rubygems_#{rg}")
+            system("git clone git://github.com/jbarnette/rubygems.git tmp/rubygems_#{rg} && cd tmp/rubygems_#{rg} && git reset --hard #{rg}")
+          end
+          ENV["RUBYOPT"] = "-I#{File.expand_path("tmp/rubygems_#{rg}/lib")} #{rubyopt}"
+        end
+
+        task rg => "clone_rubygems_#{rg}"
+        task "rubygems:all" => rg
+      end
+    end
+
+    namespace :ruby do
+      # Ruby 1.8.6, 1.8.7, and 1.9.2 specs
+      task "ensure_rvm" do
+        raise "RVM is not available" unless File.exist?(File.expand_path("~/.rvm/scripts/rvm"))
+      end
+
+      %w(1.8.6-p399 1.8.7-p302 1.9.2-p0).each do |ruby|
+        ruby_cmd = File.expand_path("~/.rvm/bin/ruby-#{ruby}")
+
+        desc "Run specs on Ruby #{ruby}"
+        RSpec::Core::RakeTask.new(ruby) do |t|
+          t.rspec_opts = %w(-fs --color)
+          t.ruby_opts  = %w(-w)
+        end
+
+        task "ensure_ruby_#{ruby}" do
+          raise "Could not find Ruby #{ruby} at #{ruby_cmd}" unless File.exist?(ruby_cmd)
+        end
+
+        task "ensure_ruby_#{ruby}" => "ensure_rvm"
+        task ruby => "ensure_ruby_#{ruby}"
+        task "ruby:all" => ruby
+      end
+    end
+
+  end
+
+rescue LoadError
+  task :spec do
+    abort "Run `rake spec:deps` to be able to run the specs"
+  end
+end
+
+namespace :spec do
+  desc "Ensure spec dependencies are installed"
+  task :deps do
+    sh "gem list ronn | (grep 'ronn' 1> /dev/null) || gem install ronn --no-ri --no-rdoc"
+    sh "gem list rspec | (grep 'rspec (2.0' 1> /dev/null) || gem install rspec --no-ri --no-rdoc"
+  end
+end
+
+namespace :man do
+  directory "lib/bundler/man"
+
+  Dir["man/*.ronn"].each do |ronn|
+    basename = File.basename(ronn, ".ronn")
+    roff = "lib/bundler/man/#{basename}"
+
+    file roff => ["lib/bundler/man", ronn] do
+      sh "ronn --roff --pipe #{ronn} > #{roff}"
+    end
+
+    file "#{roff}.txt" => roff do
+      sh "groff -Wall -mtty-char -mandoc -Tascii #{roff} | col -b > #{roff}.txt"
+    end
+
+    task :build_all_pages => "#{roff}.txt"
+  end
+
+  desc "Build the man pages"
+  task :build => "man:build_all_pages"
+
+  desc "Clean up from the built man pages"
+  task :clean do
+    rm_rf "lib/bundler/man"
+  end
+end
+
+namespace :vendor do
+  desc "Build the vendor dir"
+  task :build => :clean do
+    sh "git clone git://github.com/wycats/thor.git lib/bundler/vendor/tmp"
+    sh "mv lib/bundler/vendor/tmp/lib/* lib/bundler/vendor/"
+    rm_rf "lib/bundler/vendor/tmp"
+  end
+
+  desc "Clean the vendor dir"
+  task :clean do
+    rm_rf "lib/bundler/vendor"
+  end
+end
+
+task :default => :spec

data/UPGRADING.md

@@ -0,0 +1,103 @@
+## Bundler 0.9 to 1.0 and above
+
+Upgrading from Bundler 0.9 to 1.0 is relatively painless. The
+Gemfile API is the same, so your old Gemfiles should continue
+to work.
+
+The "env" file that 0.9 created at `.bundle/environment.rb` has been
+removed. As a side effect of this, Passenger will only find your
+bundled gems if you install with `bundle install --deployment`.
+Alternatively, you can tell Passenger where you gems are installed,
+[something like this](http://bit.ly/passenger-gem-home).
+
+The `bundle lock` command is no longer needed, as the
+Gemfile.lock file is now automatically generated by `bundle install`.
+If you have not yet done so, add your Gemfile.lock to source control
+and check it in.
+
+Running `bundle install` no longer updates the versions of your gems.
+If you need to update just one gem, run `bundle update GEMNAME`. To
+update all gems to the newest versions possible, run `bundle update`.
+
+Bundler now supports multiple platforms, using a block syntax to
+declare platform-specific gems:
+
+    platform :jruby do
+      gem "jruby-maven-plugins"
+    end
+
+Deploying using Bundler is even easier than it was before, as Bundler
+now includes a Capistrano recipe. Simply add this line to the top of
+your deploy.rb file to run Bundler automatically as part of deploying:
+
+    require 'bundler/capistrano'
+
+For more details on deploying using bundler, see the documentation
+for the bundler cap task, and the [documentation on deploying](http://gembundler.com/v1.0/deploying.html).
+
+
+## Bundler 0.8 to 0.9 and above
+
+Upgrading to Bundler 0.9 from Bundler 0.8 requires upgrading several
+API calls in your Gemfile, and some workarounds if you are using Rails 2.3.
+
+### Gemfile Removals
+
+Bundler 0.9 removes the following Bundler 0.8 Gemfile APIs:
+
+1. `disable_system_gems`: This is now the default (and only) option
+   for bundler. Bundler uses the system gems you have specified
+   in the Gemfile, and only the system gems you have specified
+   (and their dependencies)
+2. `disable_rubygems`: This is no longer supported. We are looking
+   into ways to get the fastest performance out of each supported
+   scenario, and we will make speed the default where possible.
+3. `clear_sources`: Bundler now defaults to an empty source
+   list. If you want to include Rubygems, you can add the source
+   via source "http://gemcutter.org". If you use bundle init, this
+   source will be automatically added for you in the generated
+   Gemfile
+4. `bundle_path`: You can specify this setting when installing
+   via `bundle install /path/to/bundle`. Bundler will remember
+   where you installed the dependencies to on a particular
+   machine for future installs, loads, setups, etc.
+5. `bin_path`: Bundler no longer generates binaries in the root
+   of your app. You should use `bundle exec` to execute binaries
+   in the current context.
+
+### Gemfile Changes
+
+Bundler 0.9 changes the following Bundler 0.8 Gemfile APIs:
+
+1. Bundler 0.8 supported :only and :except as APIs for describing
+   groups of gems. Bundler 0.9 supports a single `group` method,
+   which you can use to group gems together. See the above "Group"
+   section for more information.
+
+   This means that `gem "foo", :only => :production` becomes
+   `gem "foo", :group => :production`, and
+   `only :production { gem "foo" }` becomes
+   `group :production { gem "foo" }`
+
+   The short version is: group your gems together logically, and
+   use the available commands to make use of the groups you've
+   created.
+
+2. `:require_as` becomes `:require`
+
+3. `:vendored_at` is fully removed; you should use `:path`
+
+### API Changes
+
+1. `Bundler.require_env(:environment)` becomes
+   `Bundler.require(:multiple, :groups)`. You must
+   now specify the default group (the default group is the
+   group made up of the gems not assigned to any group)
+   explicitly. So `Bundler.require_env(:test)` becomes
+   `Bundler.require(:default, :test)`
+
+2. `require 'vendor/gems/environment'`: In unlocked
+   mode, where using system gems, this becomes
+   `Bundler.setup(:multiple, :groups)`. If you don't
+   specify any groups, this puts all groups on the load
+   path. In locked, mode, it becomes `require '.bundle/environment'`

data/bin/bundle

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+# Check if an older version of bundler is installed
+require 'bundler'
+$:.each do |path|
+  if path =~ %r'/bundler-0.(\d+)' && $1.to_i < 9
+    abort "Please remove older versions of bundler. This can be done by running `gem cleanup bundler`."
+  end
+end
+require 'bundler/cli'
+
+begin
+  Bundler::CLI.start
+rescue Bundler::BundlerError => e
+  Bundler.ui.error e.message
+  Bundler.ui.error e.backtrace.join("\n") if ENV["DEBUG"]
+  exit e.status_code
+rescue Interrupt
+  Bundler.ui.error "\nQuitting..."
+  exit 1
+end

data/bundler.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'bundler/version'
+
+Gem::Specification.new do |s|
+  s.name        = "honkster-bundler"
+  s.version     = Bundler::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Carl Lerche", "Yehuda Katz", "André Arko"]
+  s.email       = ["carlhuda@engineyard.com"]
+  s.homepage    = "http://gembundler.com"
+  s.summary     = %q{The best way to manage your application's dependencies}
+  s.description = %q{Bundler manages an application's dependencies through its entire life, across many machines, systematically and repeatably}
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "bundler"
+
+  s.add_development_dependency "ronn"
+  s.add_development_dependency "rspec", "2.0.0.rc"
+
+  # Man files are required because they are ignored by git
+  man_files            = Dir.glob("lib/bundler/man/**/*")
+  s.files              = `git ls-files`.split("\n") + man_files
+  s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables        = %w(bundle)
+  s.default_executable = "bundle"
+  s.require_paths      = ["lib"]
+end

data/lib/bundler.rb

@@ -0,0 +1,268 @@
+require 'rbconfig'
+require 'fileutils'
+require 'pathname'
+require 'yaml'
+require 'bundler/rubygems_ext'
+require 'bundler/version'
+
+module Bundler
+  ORIGINAL_ENV = ENV.to_hash
+
+  autoload :Definition,          'bundler/definition'
+  autoload :Dependency,          'bundler/dependency'
+  autoload :Dsl,                 'bundler/dsl'
+  autoload :Environment,         'bundler/environment'
+  autoload :GemHelper,           'bundler/gem_helper'
+  autoload :Graph,               'bundler/graph'
+  autoload :Index,               'bundler/index'
+  autoload :Installer,           'bundler/installer'
+  autoload :LazySpecification,   'bundler/lazy_specification'
+  autoload :LockfileParser,      'bundler/lockfile_parser'
+  autoload :RemoteSpecification, 'bundler/remote_specification'
+  autoload :Resolver,            'bundler/resolver'
+  autoload :Runtime,             'bundler/runtime'
+  autoload :Settings,            'bundler/settings'
+  autoload :SharedHelpers,       'bundler/shared_helpers'
+  autoload :SpecSet,             'bundler/spec_set'
+  autoload :Source,              'bundler/source'
+  autoload :Specification,       'bundler/shared_helpers'
+  autoload :UI,                  'bundler/ui'
+
+  class BundlerError < StandardError
+    def self.status_code(code = nil)
+      define_method(:status_code) { code }
+    end
+  end
+
+  class GemfileNotFound  < BundlerError; status_code(10) ; end
+  class GemNotFound      < BundlerError; status_code(7)  ; end
+  class GemfileError     < BundlerError; status_code(4)  ; end
+  class PathError        < BundlerError; status_code(13) ; end
+  class GitError         < BundlerError; status_code(11) ; end
+  class DeprecatedError  < BundlerError; status_code(12) ; end
+  class GemspecError     < BundlerError; status_code(14) ; end
+  class DslError         < BundlerError; status_code(15) ; end
+  class ProductionError  < BundlerError; status_code(16) ; end
+  class InvalidOption    < DslError                      ; end
+
+
+  WINDOWS = RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw)!
+  NULL    = WINDOWS ? "NUL" : "/dev/null"
+
+  # Internal errors, should be rescued
+  class VersionConflict  < BundlerError
+    attr_reader :conflicts
+
+    def initialize(conflicts, msg = nil)
+      super(msg)
+      @conflicts = conflicts
+    end
+
+    status_code(6)
+  end
+
+  class InvalidSpecSet < StandardError; end
+
+  class << self
+    attr_writer :ui, :bundle_path
+
+    def configure
+      @configured ||= begin
+        configure_gem_home_and_path
+        true
+      end
+    end
+
+    def ui
+      @ui ||= UI.new
+    end
+
+    def bundle_path
+      # STDERR.puts settings.path
+      @bundle_path ||= Pathname.new(settings.path).expand_path(root)
+    end
+
+    def bin_path
+      @bin_path ||= begin
+        path = settings[:bin] || "bin"
+        path = Pathname.new(path).expand_path(root)
+        FileUtils.mkdir_p(path)
+        Pathname.new(path).expand_path
+      end
+    end
+
+    def setup(*groups)
+      return @setup if defined?(@setup) && @setup
+
+      if groups.empty?
+        # Load all groups, but only once
+        @setup = load.setup
+      else
+        # Figure out which groups haven't been loaded yet
+        unloaded = groups - (@completed_groups || [])
+        # Record groups that are now loaded
+        @completed_groups = groups | (@completed_groups || [])
+        # Load any groups that are not yet loaded
+        unloaded.any? ? load.setup(*unloaded) : load
+      end
+    end
+
+    def require(*groups)
+      setup(*groups).require(*groups)
+    end
+
+    def load
+      @load ||= Runtime.new(root, definition)
+    end
+
+    def environment
+      Bundler::Environment.new(root, definition)
+    end
+
+    def definition(unlock = nil)
+      @definition = nil if unlock
+      @definition ||= begin
+        configure
+        upgrade_lockfile
+        Definition.build(default_gemfile, default_lockfile, unlock)
+      end
+    end
+
+    def ruby_scope
+      "#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}"
+    end
+
+    def user_bundle_path
+      Pathname.new(Gem.user_home).join(".bundler")
+    end
+
+    def home
+      bundle_path.join("bundler")
+    end
+
+    def install_path
+      home.join("gems")
+    end
+
+    def specs_path
+      bundle_path.join("specifications")
+    end
+
+    def cache
+      bundle_path.join("cache/bundler")
+    end
+
+    def root
+      default_gemfile.dirname.expand_path
+    end
+
+    def app_config_path
+      ENV['BUNDLE_APP_CONFIG'] ?
+        Pathname.new(ENV['BUNDLE_APP_CONFIG']).expand_path(root) :
+        root.join('.bundle')
+    end
+
+    def app_cache
+      root.join("vendor/cache")
+    end
+
+    def tmp
+      user_bundle_path.join("tmp", Process.pid.to_s)
+    end
+
+    def settings
+      @settings ||= Settings.new(app_config_path)
+    end
+
+    def with_clean_env
+      bundled_env = ENV.to_hash
+      ENV.replace(ORIGINAL_ENV)
+      yield
+    ensure
+      ENV.replace(bundled_env.to_hash)
+    end
+
+    def default_gemfile
+      SharedHelpers.default_gemfile
+    end
+
+    def default_lockfile
+      SharedHelpers.default_lockfile
+    end
+
+    def requires_sudo?
+      path = bundle_path
+      path = path.parent until path.exist?
+      sudo_present = !`which sudo 2>#{NULL}`.empty?
+
+      settings.allow_sudo? && !File.writable?(path) && sudo_present
+    end
+
+    def mkdir_p(path)
+      if requires_sudo?
+        sudo "mkdir -p '#{path}'" unless File.exist?(path)
+      else
+        FileUtils.mkdir_p(path)
+      end
+    end
+
+    def sudo(str)
+      `sudo -p 'Enter your password to install the bundled RubyGems to your system: ' #{str}`
+    end
+
+    def read_file(file)
+      File.open(file, "rb") { |f| f.read }
+    end
+
+    def load_gemspec(file)
+      path = Pathname.new(file)
+      # Eval the gemspec from its parent directory
+      Dir.chdir(path.dirname) do
+        begin
+          Gem::Specification.from_yaml(path.basename)
+          # Raises ArgumentError if the file is not valid YAML
+        rescue ArgumentError, SyntaxError, Gem::EndOfYAMLException, Gem::Exception
+          begin
+            eval(File.read(path.basename), TOPLEVEL_BINDING, path.expand_path.to_s)
+          rescue LoadError => e
+            original_line = e.backtrace.find { |line| line.include?(path.to_s) }
+            msg  = "There was a LoadError while evaluating #{path.basename}:\n  #{e.message}"
+            msg << " from\n  #{original_line}" if original_line
+            msg << "\n"
+
+            if RUBY_VERSION >= "1.9.0"
+              msg << "\nDoes it try to require a relative path? That doesn't work in Ruby 1.9."
+            end
+
+            raise GemspecError, msg
+          end
+        end
+      end
+    end
+
+  private
+
+    def configure_gem_home_and_path
+      if settings[:disable_shared_gems]
+        ENV['GEM_PATH'] = ''
+        ENV['GEM_HOME'] = File.expand_path(bundle_path, root)
+      elsif Gem.dir != bundle_path.to_s
+        paths = [Gem.dir, Gem.path].flatten.compact.uniq.reject{|p| p.empty? }
+        ENV["GEM_PATH"] = paths.join(File::PATH_SEPARATOR)
+        ENV["GEM_HOME"] = bundle_path.to_s
+      end
+
+      FileUtils.mkdir_p bundle_path.to_s
+      Gem.clear_paths
+    end
+
+    def upgrade_lockfile
+      lockfile = default_lockfile
+      if lockfile.exist? && lockfile.read(3) == "---"
+        Bundler.ui.warn "Detected Gemfile.lock generated by 0.9, deleting..."
+        lockfile.rmtree
+      end
+    end
+
+  end
+end