rkh-bundler 1.2.0.pre

data/bundler.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'bundler/version'
+
+Gem::Specification.new do |s|
+  s.name        = "rkh-bundler"
+  s.version     = Bundler::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["André Arko", "Terence Lee", "Carl Lerche", "Yehuda Katz"]
+  s.email       = ["andre@arko.net"]
+  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_ruby_version     = ">= 1.8.7"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "bundler"
+
+  s.add_development_dependency "ronn"
+  s.add_development_dependency "rspec", "~> 2.0"
+
+  # Man files are required because they are ignored by git
+  man_files            = Dir.glob("lib/bundler/man/**/*")
+  git_files            = `git ls-files`.split("\n") rescue ''
+  s.files              = git_files + man_files
+  s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables        = %w(bundle)
+  s.require_paths      = ["lib"]
+end

data/lib/bundler.rb

@@ -0,0 +1,353 @@
+require 'rbconfig'
+require 'fileutils'
+require 'pathname'
+require 'bundler/psyched_yaml'
+require 'bundler/rubygems_ext'
+require 'bundler/rubygems_integration'
+require 'bundler/version'
+
+module Bundler
+  ORIGINAL_ENV = ENV.to_hash
+
+  autoload :Definition,            'bundler/definition'
+  autoload :Dependency,            'bundler/dependency'
+  autoload :DepProxy,              'bundler/dep_proxy'
+  autoload :Dsl,                   'bundler/dsl'
+  autoload :EndpointSpecification, 'bundler/endpoint_specification'
+  autoload :Environment,           'bundler/environment'
+  autoload :Fetcher,               'bundler/fetcher'
+  autoload :GemHelper,             'bundler/gem_helper'
+  autoload :GemHelpers,            'bundler/gem_helpers'
+  autoload :GemInstaller,          'bundler/gem_installer'
+  autoload :Graph,                 'bundler/graph'
+  autoload :Index,                 'bundler/index'
+  autoload :Installer,             'bundler/installer'
+  autoload :LazySpecification,     'bundler/lazy_specification'
+  autoload :LockfileParser,        'bundler/lockfile_parser'
+  autoload :MatchPlatform,         'bundler/match_platform'
+  autoload :RemoteSpecification,   'bundler/remote_specification'
+  autoload :Resolver,              'bundler/resolver'
+  autoload :RubyVersion,           'bundler/ruby_version'
+  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 :SystemRubyVersion,     'bundler/ruby_version'
+  autoload :UI,                    'bundler/ui'
+
+  class BundlerError < StandardError
+    def self.status_code(code)
+      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 InstallError        < BundlerError; status_code(5)  ; end
+  class InstallHookError    < BundlerError; status_code(6)  ; 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
+  class HTTPError           < BundlerError; status_code(17) ; end
+  class RubyVersionMismatch < BundlerError; status_code(18) ; end
+
+
+  WINDOWS = RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw)!
+  FREEBSD = RbConfig::CONFIG["host_os"] =~ /bsd/
+  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 ||= configure_gem_home_and_path
+    end
+
+    def ui
+      @ui ||= UI.new
+    end
+
+    # Returns absolute path of where gems are installed on the filesystem.
+    def bundle_path
+      @bundle_path ||= Pathname.new(settings.path).expand_path(root)
+    end
+
+    # Returns absolute location of where binstubs are installed to.
+    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)
+      # Just return if all groups are already loaded
+      return @setup if defined?(@setup)
+
+      definition.validate_ruby!
+
+      if groups.empty?
+        # Load all groups, but only once
+        @setup = load.setup
+      else
+        @completed_groups ||= []
+        # Figure out which groups haven't been loaded yet
+        unloaded = groups - @completed_groups
+        # Record groups that are now loaded
+        @completed_groups = groups
+        unloaded.any? ? load.setup(*groups) : 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
+      "#{Bundler.rubygems.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}"
+    end
+
+    def user_bundle_path
+      Pathname.new(Bundler.rubygems.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_original_env
+      bundled_env = ENV.to_hash
+      ENV.replace(ORIGINAL_ENV)
+      yield
+    ensure
+      ENV.replace(bundled_env.to_hash)
+    end
+
+    def with_clean_env
+      with_original_env do
+        ENV.delete_if { |k,_| k[0,7] == 'BUNDLE_' }
+        if ENV.has_key? 'RUBYOPT'
+          ENV['RUBYOPT'] = ENV['RUBYOPT'].sub '-rbundler/setup', ''
+          ENV['RUBYOPT'] = ENV['RUBYOPT'].sub "-I#{File.expand_path('..', __FILE__)}", ''
+        end
+        yield
+      end
+    end
+
+    def clean_system(*args)
+      with_clean_env { Kernel.system(*args) }
+    end
+
+    def clean_exec(*args)
+      with_clean_env { Kernel.exec(*args) }
+    end
+
+    def default_gemfile
+      SharedHelpers.default_gemfile
+    end
+
+    def default_lockfile
+      SharedHelpers.default_lockfile
+    end
+
+    def system_bindir
+      # Gem.bindir doesn't always return the location that Rubygems will install
+      # system binaries. If you put '-n foo' in your .gemrc, Rubygems will
+      # install binstubs there instead. Unfortunately, Rubygems doesn't expose
+      # that directory at all, so rather than parse .gemrc ourselves, we allow
+      # the directory to be set as well, via `bundle config bindir foo`.
+      Bundler.settings[:system_bindir] || Bundler.rubygems.gem_bindir
+    end
+
+    def requires_sudo?
+      return @requires_sudo if defined?(@checked_for_sudo)
+
+      path = bundle_path
+      path = path.parent until path.exist?
+      sudo_present = which "sudo"
+      bin_dir = Pathname.new(Bundler.system_bindir)
+      bin_dir = bin_dir.parent until bin_dir.exist?
+
+      @checked_for_sudo = true
+      sudo_gems = !File.writable?(path) || !File.writable?(bin_dir)
+      @requires_sudo = settings.allow_sudo? && sudo_gems && 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 which(executable)
+      if File.executable?(executable)
+        executable
+      else
+        path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
+          File.executable?(File.join(p, executable))
+        end
+        path && File.expand_path(executable, 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)
+      @gemspec_cache ||= {}
+      key = File.expand_path(file)
+      spec = ( @gemspec_cache[key] ||= load_gemspec_uncached(file) )
+      # Protect against caching side-effected gemspecs by returning a
+      # new instance each time.
+      spec.dup if spec
+    end
+
+    def load_gemspec_uncached(file)
+      path = Pathname.new(file)
+      # Eval the gemspec from its parent directory
+      Dir.chdir(path.dirname.to_s) do
+        contents = File.read(path.basename.to_s)
+        begin
+          Gem::Specification.from_yaml(contents)
+          # Raises ArgumentError if the file is not valid YAML
+        rescue ArgumentError, SyntaxError, Gem::EndOfYAMLException, Gem::Exception
+          begin
+            eval(contents, 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"
+              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
+
+    def clear_gemspec_cache
+      @gemspec_cache = {}
+    end
+
+  private
+
+    def configure_gem_home_and_path
+      blank_home = ENV['GEM_HOME'].nil? || ENV['GEM_HOME'].empty?
+
+      if settings[:disable_shared_gems]
+        ENV['GEM_PATH'] = ''
+        configure_gem_home
+      elsif blank_home || Bundler.rubygems.gem_dir != bundle_path.to_s
+        possibles = [Bundler.rubygems.gem_dir, Bundler.rubygems.gem_path]
+        paths = possibles.flatten.compact.uniq.reject { |p| p.empty? }
+        ENV["GEM_PATH"] = paths.join(File::PATH_SEPARATOR)
+        configure_gem_home
+      end
+
+      Bundler.rubygems.refresh
+      bundle_path
+    end
+
+    def configure_gem_home
+      # TODO: This mkdir_p is only needed for JRuby <= 1.5 and should go away (GH #602)
+      FileUtils.mkdir_p bundle_path.to_s rescue nil
+
+      ENV['GEM_HOME'] = File.expand_path(bundle_path, root)
+      Bundler.rubygems.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

data/lib/bundler/capistrano.rb

@@ -0,0 +1,11 @@
+# Capistrano task for Bundler.
+#
+# Just add "require 'bundler/capistrano'" in your Capistrano deploy.rb, and
+# Bundler will be activated after each new deployment.
+require 'bundler/deployment'
+
+Capistrano::Configuration.instance(:must_exist).load do
+  after "deploy:finalize_update", "bundle:install"
+  Bundler::Deployment.define_task(self, :task, :except => { :no_release => true })
+  set :rake, lambda { "#{fetch(:bundle_cmd, "bundle")} exec rake" }
+end

data/lib/bundler/cli.rb

@@ -0,0 +1,693 @@
+require 'bundler/vendored_thor'
+require 'rubygems/user_interaction'
+require 'rubygems/config_file'
+
+module Bundler
+  class CLI < Thor
+    include Thor::Actions
+
+    def initialize(*)
+      super
+      the_shell = (options["no-color"] ? Thor::Shell::Basic.new : shell)
+      Bundler.ui = UI::Shell.new(the_shell)
+      Bundler.ui.debug! if options["verbose"]
+      Bundler.rubygems.ui = UI::RGProxy.new(Bundler.ui)
+    end
+
+    check_unknown_options!
+
+    default_task :install
+    class_option "no-color", :type => :boolean, :banner => "Disable colorization in output"
+    class_option "verbose",  :type => :boolean, :banner => "Enable verbose output mode", :aliases => "-V"
+
+    def help(cli = nil)
+      case cli
+      when "gemfile" then command = "gemfile.5"
+      when nil       then command = "bundle"
+      else command = "bundle-#{cli}"
+      end
+
+      manpages = %w(
+          bundle
+          bundle-config
+          bundle-exec
+          bundle-install
+          bundle-package
+          bundle-update
+          gemfile.5)
+
+      if manpages.include?(command)
+        root = File.expand_path("../man", __FILE__)
+
+        if have_groff? && root !~ %r{^file:/.+!/META-INF/jruby.home/.+}
+          groff   = "groff -Wall -mtty-char -mandoc -Tascii"
+          pager   = ENV['MANPAGER'] || ENV['PAGER'] || 'less -R'
+
+          Kernel.exec "#{groff} #{root}/#{command} | #{pager}"
+        else
+          puts File.read("#{root}/#{command}.txt")
+        end
+      else
+        super
+      end
+    end
+
+    desc "init", "Generates a Gemfile into the current working directory"
+    long_desc <<-D
+      Init generates a default Gemfile in the current working directory. When adding a
+      Gemfile to a gem with a gemspec, the --gemspec option will automatically add each
+      dependency listed in the gemspec file to the newly created Gemfile.
+    D
+    method_option "gemspec", :type => :string, :banner => "Use the specified .gemspec to create the Gemfile"
+    def init
+      opts = options.dup
+      if File.exist?("Gemfile")
+        Bundler.ui.error "Gemfile already exists at #{Dir.pwd}/Gemfile"
+        exit 1
+      end
+
+      if opts[:gemspec]
+        gemspec = File.expand_path(opts[:gemspec])
+        unless File.exist?(gemspec)
+          Bundler.ui.error "Gem specification #{gemspec} doesn't exist"
+          exit 1
+        end
+        spec = Gem::Specification.load(gemspec)
+        puts "Writing new Gemfile to #{Dir.pwd}/Gemfile"
+        File.open('Gemfile', 'wb') do |file|
+          file << "# Generated from #{gemspec}\n"
+          file << spec.to_gemfile
+        end
+      else
+        puts "Writing new Gemfile to #{Dir.pwd}/Gemfile"
+        FileUtils.cp(File.expand_path('../templates/Gemfile', __FILE__), 'Gemfile')
+      end
+    end
+
+    desc "check", "Checks if the dependencies listed in Gemfile are satisfied by currently installed gems"
+    long_desc <<-D
+      Check searches the local machine for each of the gems requested in the Gemfile. If
+      all gems are found, Bundler prints a success message and exits with a status of 0.
+      If not, the first missing gem is listed and Bundler exits status 1.
+    D
+    method_option "gemfile", :type => :string, :banner =>
+      "Use the specified gemfile instead of Gemfile"
+    method_option "path", :type => :string, :banner =>
+      "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine"
+    def check
+      ENV['BUNDLE_GEMFILE'] = File.expand_path(options[:gemfile]) if options[:gemfile]
+
+      Bundler.settings[:path] = File.expand_path(options[:path]) if options[:path]
+      begin
+        definition = Bundler.definition
+        definition.validate_ruby!
+        not_installed = definition.missing_specs
+      rescue GemNotFound, VersionConflict
+        Bundler.ui.error "Your Gemfile's dependencies could not be satisfied"
+        Bundler.ui.warn  "Install missing gems with `bundle install`"
+        exit 1
+      end
+
+      if not_installed.any?
+        Bundler.ui.error "The following gems are missing"
+        not_installed.each { |s| Bundler.ui.error " * #{s.name} (#{s.version})" }
+        Bundler.ui.warn "Install missing gems with `bundle install`"
+        exit 1
+      elsif !Bundler.default_lockfile.exist? && Bundler.settings[:frozen]
+        Bundler.ui.error "This bundle has been frozen, but there is no Gemfile.lock present"
+        exit 1
+      else
+        Bundler.load.lock
+        Bundler.ui.info "The Gemfile's dependencies are satisfied"
+      end
+    end
+
+    desc "install", "Install the current environment to the system"
+    long_desc <<-D
+      Install will install all of the gems in the current bundle, making them available
+      for use. In a freshly checked out repository, this command will give you the same
+      gem versions as the last person who updated the Gemfile and ran `bundle update`.
+
+      Passing [DIR] to install (e.g. vendor) will cause the unpacked gems to be installed
+      into the [DIR] directory rather than into system gems.
+
+      If the bundle has already been installed, bundler will tell you so and then exit.
+    D
+    method_option "without", :type => :array, :banner =>
+      "Exclude gems that are part of the specified named group."
+    method_option "gemfile", :type => :string, :banner =>
+      "Use the specified gemfile instead of Gemfile"
+    method_option "no-prune", :type => :boolean, :banner =>
+      "Don't remove stale gems from the cache."
+    method_option "no-cache", :type => :boolean, :banner =>
+      "Don't update the existing gem cache."
+    method_option "quiet", :type => :boolean, :banner =>
+      "Only output warnings and errors."
+    method_option "local", :type => :boolean, :banner =>
+      "Do not attempt to fetch gems remotely and use the gem cache instead"
+    method_option "binstubs", :type => :string, :lazy_default => "bin", :banner =>
+      "Generate bin stubs for bundled gems to ./bin"
+    method_option "shebang", :type => :string, :banner =>
+      "Specify a different shebang executable name than the default (usually 'ruby')"
+    method_option "path", :type => :string, :banner =>
+      "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine"
+    method_option "system", :type => :boolean, :banner =>
+      "Install to the system location ($BUNDLE_PATH or $GEM_HOME) even if the bundle was previously installed somewhere else for this application"
+    method_option "frozen", :type => :boolean, :banner =>
+      "Do not allow the Gemfile.lock to be updated after this install"
+    method_option "deployment", :type => :boolean, :banner =>
+      "Install using defaults tuned for deployment environments"
+    method_option "standalone", :type => :array, :lazy_default => [], :banner =>
+      "Make a bundle that can work without the Bundler runtime"
+    method_option "full-index", :type => :boolean, :banner =>
+      "Use the rubygems modern index instead of the API endpoint"
+    method_option "clean", :type => :boolean, :banner =>
+      "Run bundle clean automatically after install"
+    def install
+      opts = options.dup
+      if opts[:without]
+        opts[:without].map!{|g| g.split(" ") }
+        opts[:without].flatten!
+        opts[:without].map!{|g| g.to_sym }
+      end
+
+      # Can't use Bundler.settings for this because settings needs gemfile.dirname
+      ENV['BUNDLE_GEMFILE'] = File.expand_path(opts[:gemfile]) if opts[:gemfile]
+      ENV['RB_USER_INSTALL'] = '1' if Bundler::FREEBSD
+
+      # Just disable color in deployment mode
+      Bundler.ui.shell = Thor::Shell::Basic.new if opts[:deployment]
+
+      if (opts[:path] || opts[:deployment]) && opts[:system]
+        Bundler.ui.error "You have specified both a path to install your gems to, \n" \
+                         "as well as --system. Please choose."
+        exit 1
+      end
+
+      if opts[:deployment] || opts[:frozen]
+        unless Bundler.default_lockfile.exist?
+          flag = opts[:deployment] ? '--deployment' : '--frozen'
+          raise ProductionError, "The #{flag} flag requires a Gemfile.lock. Please make " \
+                                 "sure you have checked your Gemfile.lock into version control " \
+                                 "before deploying."
+        end
+
+        if Bundler.root.join("vendor/cache").exist?
+          opts[:local] = true
+        end
+
+        Bundler.settings[:frozen] = '1'
+      end
+
+      # When install is called with --no-deployment, disable deployment mode
+      if opts[:deployment] == false
+        Bundler.settings.delete(:frozen)
+        opts[:system] = true
+      end
+
+      # Can't use Bundler.settings for this because settings needs gemfile.dirname
+      Bundler.settings[:path]   = nil if opts[:system]
+      Bundler.settings[:path]   = "vendor/bundle" if opts[:deployment]
+      Bundler.settings[:path]   = opts[:path] if opts[:path]
+      Bundler.settings[:path] ||= "bundle" if opts[:standalone]
+      Bundler.settings[:bin]    = opts["binstubs"] if opts[:binstubs]
+      Bundler.settings[:shebang] = opts["shebang"] if opts[:shebang]
+      Bundler.settings[:no_prune] = true if opts["no-prune"]
+      Bundler.settings[:disable_shared_gems] = Bundler.settings[:path] ? '1' : nil
+      Bundler.settings.without = opts[:without]
+      Bundler.ui.be_quiet! if opts[:quiet]
+      Bundler.settings[:clean] = opts[:clean] if opts[:clean]
+
+      Bundler::Fetcher.disable_endpoint = opts["full-index"]
+      # rubygems plugins sometimes hook into the gem install process
+      Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
+
+      definition = Bundler.definition
+      definition.validate_ruby!
+      Installer.install(Bundler.root, definition, opts)
+      Bundler.load.cache if Bundler.root.join("vendor/cache").exist? && !options["no-cache"]
+
+      if Bundler.settings[:path]
+        absolute_path = File.expand_path(Bundler.settings[:path])
+        relative_path = absolute_path.sub(File.expand_path('.'), '.')
+        Bundler.ui.confirm "Your bundle is complete! " +
+          "It was installed into #{relative_path}"
+      else
+        Bundler.ui.confirm "Your bundle is complete! " +
+          "Use `bundle show [gemname]` to see where a bundled gem is installed."
+      end
+      Installer.post_install_messages.to_a.each do |name, msg|
+        Bundler.ui.confirm "Post-install message from #{name}:\n#{msg}"
+      end
+
+      clean if Bundler.settings[:clean] && Bundler.settings[:path]
+    rescue GemNotFound => e
+      if opts[:local] && Bundler.app_cache.exist?
+        Bundler.ui.warn "Some gems seem to be missing from your vendor/cache directory."
+      end
+
+      if Bundler.definition.no_sources?
+        Bundler.ui.warn "Your Gemfile has no remote sources. If you need " \
+          "gems that are not already on\nyour machine, add a line like this " \
+          "to your Gemfile:\n    source 'https://rubygems.org'"
+      end
+      raise e
+    end
+
+    desc "update", "update the current environment"
+    long_desc <<-D
+      Update will install the newest versions of the gems listed in the Gemfile. Use
+      update when you have changed the Gemfile, or if you want to get the newest
+      possible versions of the gems in the bundle.
+    D
+    method_option "source", :type => :array, :banner => "Update a specific source (and all gems associated with it)"
+    method_option "local", :type => :boolean, :banner =>
+      "Do not attempt to fetch gems remotely and use the gem cache instead"
+    method_option "quiet", :type => :boolean, :banner =>
+      "Only output warnings and errors."
+    method_option "full-index", :type => :boolean, :banner =>
+        "Use the rubygems modern index instead of the API endpoint"
+    def update(*gems)
+      sources = Array(options[:source])
+      Bundler.ui.be_quiet! if options[:quiet]
+
+      if gems.empty? && sources.empty?
+        # We're doing a full update
+        Bundler.definition(true)
+      else
+        Bundler.definition(:gems => gems, :sources => sources)
+      end
+
+      Bundler::Fetcher.disable_endpoint = options["full-index"]
+
+      opts = {"update" => true, "local" => options[:local]}
+      # rubygems plugins sometimes hook into the gem install process
+      Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
+
+      Bundler.definition.validate_ruby!
+      Installer.install Bundler.root, Bundler.definition, opts
+      Bundler.load.cache if Bundler.root.join("vendor/cache").exist?
+      clean if Bundler.settings[:clean] && Bundler.settings[:path]
+      Bundler.ui.confirm "Your bundle is updated! " +
+        "Use `bundle show [gemname]` to see where a bundled gem is installed."
+    end
+
+    desc "show [GEM]", "Shows all gems that are part of the bundle, or the path to a given gem"
+    long_desc <<-D
+      Show lists the names and versions of all gems that are required by your Gemfile.
+      Calling show with [GEM] will list the exact location of that gem on your machine.
+    D
+    method_option "paths", :type => :boolean,
+      :banner => "List the paths of all gems that are required by your Gemfile."
+    def show(gem_name = nil)
+      Bundler.definition.validate_ruby!
+      Bundler.load.lock
+
+      if gem_name
+        Bundler.ui.info locate_gem(gem_name)
+      elsif options[:paths]
+        Bundler.load.specs.sort_by { |s| s.name }.each do |s|
+          Bundler.ui.info locate_gem(s.name)
+        end
+      else
+        Bundler.ui.info "Gems included by the bundle:"
+        Bundler.load.specs.sort_by { |s| s.name }.each do |s|
+          Bundler.ui.info "  * #{s.name} (#{s.version}#{s.git_version})"
+        end
+      end
+    end
+    map %w(list) => "show"
+
+    desc "outdated [GEM]", "list installed gems with newer versions available"
+    long_desc <<-D
+      Outdated lists the names and versions of gems that have a newer version available
+      in the given source. Calling outdated with [GEM [GEM]] will only check for newer
+      versions of the given gems. By default, available prerelease gems will be ignored.
+    D
+    method_option "pre", :type => :boolean, :banner => "Check for newer pre-release gems"
+    method_option "source", :type => :array, :banner => "Check against a specific source"
+    method_option "local", :type => :boolean, :banner =>
+      "Do not attempt to fetch gems remotely and use the gem cache instead"
+    def outdated(*gems)
+      sources = Array(options[:source])
+      Bundler.definition.validate_ruby!
+      current_specs = Bundler.load.specs
+
+      if gems.empty? && sources.empty?
+        # We're doing a full update
+        definition = Bundler.definition(true)
+      else
+        definition = Bundler.definition(:gems => gems, :sources => sources)
+      end
+      options["local"] ? definition.resolve_with_cache! : definition.resolve_remotely!
+
+      Bundler.ui.info ""
+      if options["pre"]
+        Bundler.ui.info "Outdated gems included in the bundle (including pre-releases):"
+      else
+        Bundler.ui.info "Outdated gems included in the bundle:"
+      end
+
+      out_count = 0
+      # Loop through the current specs
+      current_specs.each do |current_spec|
+        next if !gems.empty? && !gems.include?(current_spec.name)
+
+        active_spec = definition.index[current_spec.name].sort_by { |b| b.version }
+
+        if !current_spec.version.prerelease? && !options[:pre] && active_spec.size > 1
+          active_spec = active_spec.delete_if { |b| b.respond_to?(:version) && b.version.prerelease? }
+        end
+
+        active_spec = active_spec.last
+        next if active_spec.nil?
+
+        gem_outdated = Gem::Version.new(active_spec.version) > Gem::Version.new(current_spec.version)
+        git_outdated = current_spec.git_version != active_spec.git_version
+        if gem_outdated || git_outdated
+          spec_version    = "#{active_spec.version}#{active_spec.git_version}"
+          current_version = "#{current_spec.version}#{current_spec.git_version}"
+          Bundler.ui.info "  * #{active_spec.name} (#{spec_version} > #{current_version})"
+          out_count += 1
+        end
+        Bundler.ui.debug "from #{active_spec.loaded_from}"
+      end
+
+      Bundler.ui.info "  Your bundle is up to date!" if out_count < 1
+      Bundler.ui.info ""
+    end
+
+    desc "cache", "Cache all the gems to vendor/cache", :hide => true
+    method_option "no-prune",  :type => :boolean, :banner => "Don't remove stale gems from the cache."
+    method_option "all",  :type => :boolean, :banner => "Include all sources (including path and git)."
+    def cache
+      Bundler.definition.validate_ruby!
+      Bundler.definition.resolve_with_cache!
+      setup_cache_all
+      Bundler.load.cache
+      Bundler.settings[:no_prune] = true if options["no-prune"]
+      Bundler.load.lock
+    rescue GemNotFound => e
+      Bundler.ui.error(e.message)
+      Bundler.ui.warn "Run `bundle install` to install missing gems."
+      exit 128
+    end
+
+    desc "package", "Locks and then caches all of the gems into vendor/cache"
+    method_option "no-prune",  :type => :boolean, :banner => "Don't remove stale gems from the cache."
+    method_option "all",  :type => :boolean, :banner => "Include all sources (including path and git)."
+    long_desc <<-D
+      The package command will copy the .gem files for every gem in the bundle into the
+      directory ./vendor/cache. If you then check that directory into your source
+      control repository, others who check out your source will be able to install the
+      bundle without having to download any additional gems.
+    D
+    def package
+      setup_cache_all
+      install
+      # TODO: move cache contents here now that all bundles are locked
+      Bundler.load.cache
+    end
+    map %w(pack) => :package
+
+    desc "exec", "Run the command in context of the bundle"
+    long_desc <<-D
+      Exec runs a command, providing it access to the gems in the bundle. While using
+      bundle exec you can require and call the bundled gems as if they were installed
+      into the systemwide Rubygems repository.
+    D
+    def exec(*)
+      ARGV.shift # remove "exec"
+
+      Bundler.definition.validate_ruby!
+      Bundler.load.setup_environment
+
+      begin
+        # Run
+        Kernel.exec(*ARGV)
+      rescue Errno::EACCES
+        Bundler.ui.error "bundler: not executable: #{ARGV.first}"
+        exit 126
+      rescue Errno::ENOENT
+        Bundler.ui.error "bundler: command not found: #{ARGV.first}"
+        Bundler.ui.warn  "Install missing gem executables with `bundle install`"
+        exit 127
+      rescue ArgumentError
+        Bundler.ui.error "bundler: exec needs a command to run"
+        exit 128
+      end
+    end
+
+    desc "config NAME [VALUE]", "retrieve or set a configuration value"
+    long_desc <<-D
+      Retrieves or sets a configuration value. If only parameter is provided, retrieve the value. If two parameters are provided, replace the
+      existing value with the newly provided one.
+
+      By default, setting a configuration value sets it for all projects
+      on the machine.
+
+      If a global setting is superceded by local configuration, this command
+      will show the current value, as well as any superceded values and
+      where they were specified.
+    D
+    def config(*)
+      values = ARGV.dup
+      values.shift # remove config
+
+      peek = values.shift
+
+      if peek && peek =~ /^\-\-/
+        name, scope = values.shift, $'
+      else
+        name, scope = peek, "global"
+      end
+
+      unless name
+        Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
+
+        Bundler.settings.all.each do |setting|
+          Bundler.ui.confirm "#{setting}"
+          with_padding do
+            Bundler.settings.pretty_values_for(setting).each do |line|
+              Bundler.ui.info line
+            end
+          end
+          Bundler.ui.confirm ""
+        end
+        return
+      end
+
+      case scope
+      when "delete"
+        Bundler.settings.set_local(name, nil)
+        Bundler.settings.set_global(name, nil)
+      when "local", "global"
+        if values.empty?
+          Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
+          with_padding do
+            Bundler.settings.pretty_values_for(name).each { |line| Bundler.ui.info line }
+          end
+          return
+        end
+
+        locations = Bundler.settings.locations(name)
+
+        if scope == "global"
+          if local = locations[:local]
+            Bundler.ui.info "Your application has set #{name} to #{local.inspect}. This will override the " \
+              "global value you are currently setting"
+          end
+
+          if env = locations[:env]
+            Bundler.ui.info "You have a bundler environment variable for #{name} set to #{env.inspect}. " \
+              "This will take precedence over the global value you are setting"
+          end
+
+          if global = locations[:global]
+            Bundler.ui.info "You are replacing the current global value of #{name}, which is currently #{global.inspect}"
+          end
+        end
+
+        if scope == "local" && local = locations[:local]
+          Bundler.ui.info "You are replacing the current local value of #{name}, which is currently #{local.inspect}"
+        end
+
+        Bundler.settings.send("set_#{scope}", name, values.join(" "))
+      else
+        Bundler.ui.error "Invalid scope --#{scope} given. Please use --local or --global."
+        exit 1
+      end
+    end
+
+    desc "open GEM", "Opens the source directory of the given bundled gem"
+    def open(name)
+      editor = [ENV['BUNDLER_EDITOR'], ENV['VISUAL'], ENV['EDITOR']].find{|e| !e.nil? && !e.empty? }
+      if editor
+        gem_path = locate_gem(name)
+        Dir.chdir(gem_path) do
+          command = "#{editor} #{gem_path}"
+          success = system(command)
+          Bundler.ui.info "Could not run '#{command}'" unless success
+        end
+      else
+        Bundler.ui.info("To open a bundled gem, set $EDITOR or $BUNDLER_EDITOR")
+      end
+    end
+
+    desc "console [GROUP]", "Opens an IRB session with the bundle pre-loaded"
+    def console(group = nil)
+      group ? Bundler.require(:default, *(group.split.map! {|g| g.to_sym })) : Bundler.require
+      ARGV.clear
+
+      require 'irb'
+      IRB.start
+    end
+
+    desc "version", "Prints the bundler's version information"
+    def version
+      Bundler.ui.info "Bundler version #{Bundler::VERSION}"
+    end
+    map %w(-v --version) => :version
+
+    desc 'viz', "Generates a visual dependency graph"
+    long_desc <<-D
+      Viz generates a PNG file of the current Gemfile as a dependency graph.
+      Viz requires the ruby-graphviz gem (and its dependencies).
+      The associated gems must also be installed via 'bundle install'.
+    D
+    method_option :file, :type => :string, :default => 'gem_graph', :aliases => '-f', :banner => "The name to use for the generated file. see format option"
+    method_option :version, :type => :boolean, :default => false, :aliases => '-v', :banner => "Set to show each gem version."
+    method_option :requirements, :type => :boolean, :default => false, :aliases => '-r', :banner => "Set to show the version of each required dependency."
+    method_option :format, :type => :string, :default => "png", :aliases => '-F', :banner => "This is output format option. Supported format is png, jpg, svg, dot ..."
+    def viz
+      output_file = File.expand_path(options[:file])
+      output_format = options[:format]
+      graph = Graph.new(Bundler.load, output_file, options[:version], options[:requirements], options[:format])
+
+      begin
+        graph.viz
+      rescue LoadError => e
+        Bundler.ui.error e.inspect
+        Bundler.ui.warn "Make sure you have the graphviz ruby gem. You can install it with:"
+        Bundler.ui.warn "`gem install ruby-graphviz`"
+      rescue StandardError => e
+        if e.message =~ /GraphViz not installed or dot not in PATH/
+          Bundler.ui.error e.message
+          Bundler.ui.warn "The ruby graphviz gem requires GraphViz to be installed"
+        else
+          raise
+        end
+      end
+    end
+
+    desc "gem GEM", "Creates a skeleton for creating a rubygem"
+    method_option :bin, :type => :boolean, :default => false, :aliases => '-b', :banner => "Generate a binary for your library."
+    def gem(name)
+      name = name.chomp("/") # remove trailing slash if present
+      target = File.join(Dir.pwd, name)
+      constant_name = name.split('_').map{|p| p[0..0].upcase + p[1..-1] }.join
+      constant_name = constant_name.split('-').map{|q| q[0..0].upcase + q[1..-1] }.join('::') if constant_name =~ /-/
+      constant_array = constant_name.split('::')
+      FileUtils.mkdir_p(File.join(target, 'lib', name))
+      git_user_name = `git config user.name`.chomp
+      git_user_email = `git config user.email`.chomp
+      opts = {
+        :name           => name,
+        :constant_name  => constant_name,
+        :constant_array => constant_array,
+        :author         => git_user_name.empty? ? "TODO: Write your name" : git_user_name,
+        :email          => git_user_email.empty? ? "TODO: Write your email address" : git_user_email
+      }
+      template(File.join("newgem/Gemfile.tt"),               File.join(target, "Gemfile"),                opts)
+      template(File.join("newgem/Rakefile.tt"),              File.join(target, "Rakefile"),               opts)
+      template(File.join("newgem/LICENSE.tt"),               File.join(target, "LICENSE"),                opts)
+      template(File.join("newgem/README.md.tt"),             File.join(target, "README.md"),              opts)
+      template(File.join("newgem/gitignore.tt"),             File.join(target, ".gitignore"),             opts)
+      template(File.join("newgem/newgem.gemspec.tt"),        File.join(target, "#{name}.gemspec"),        opts)
+      template(File.join("newgem/lib/newgem.rb.tt"),         File.join(target, "lib/#{name}.rb"),         opts)
+      template(File.join("newgem/lib/newgem/version.rb.tt"), File.join(target, "lib/#{name}/version.rb"), opts)
+      if options[:bin]
+        template(File.join("newgem/bin/newgem.tt"),          File.join(target, 'bin', name),              opts)
+      end
+      Bundler.ui.info "Initializating git repo in #{target}"
+      Dir.chdir(target) { `git init`; `git add .` }
+    end
+
+    def self.source_root
+      File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+    end
+
+    desc "clean", "Cleans up unused gems in your bundler directory"
+    method_option "force", :type => :boolean, :default => false, :banner =>
+      "forces clean even if --path is set"
+    def clean
+      if Bundler.settings[:path] || options[:force]
+        Bundler.load.clean
+      else
+        Bundler.ui.error "Can only use bundle clean when --path is set or --force is set"
+        exit 1
+      end
+    end
+
+    desc "platform", "Displays platform compatibility information"
+    method_option "ruby", :type => :boolean, :default => false, :banner =>
+      "only display ruby related platform information"
+    def platform
+      platforms    = Bundler.definition.platforms.map {|p| "* #{p}" }
+      ruby_version = Bundler.definition.ruby_version
+      output       = []
+
+      if options[:ruby]
+        if ruby_version
+          output << ruby_version
+        else
+          output << "No ruby version specified"
+        end
+      else
+        output << "Your platform is: #{RUBY_PLATFORM}"
+        output << "Your app has gems that work on these platforms:\n#{platforms.join("\n")}"
+
+        if ruby_version
+          output << "Your Gemfile specifies a Ruby version requirement:\n* #{ruby_version}"
+
+          begin
+            Bundler.definition.validate_ruby!
+            output << "Your current platform satisfies the Ruby version requirement."
+          rescue RubyVersionMismatch => e
+            output << e.message
+          end
+        else
+          output << "Your Gemfile does not specify a Ruby version requirement."
+        end
+      end
+
+      Bundler.ui.info output.join("\n\n")
+    end
+
+  private
+
+    def setup_cache_all
+      if options.key?("all")
+        Bundler.settings[:cache_all] = options[:all] || nil
+      elsif Bundler.definition.sources.any? { |s| !s.is_a?(Source::Rubygems) }
+        Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want "    \
+          "to package them as well, please pass the --all flag. This will be the default " \
+          "on Bundler 2.0."
+      end
+    end
+
+    def have_groff?
+      !(`which groff` rescue '').empty?
+    end
+
+    def locate_gem(name)
+      spec = Bundler.load.specs.find{|s| s.name == name }
+      raise GemNotFound, "Could not find gem '#{name}' in the current bundle." unless spec
+      if spec.name == 'bundler'
+        return File.expand_path('../../../', __FILE__)
+      end
+      spec.full_gem_path
+    end
+
+  end
+end