bundler 0.9.26 → 1.0.0.beta.1

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.10.0
+
+  - No `bundle lock` command. Locking happens automatically on install or update
+  - No .bundle/environment.rb. Require 'bundler/setup' instead.
+  - $BUNDLE_HOME defaults to $GEM_HOME instead of ~/.bundle
+  - Remove lockfiles generated by 0.9
+
 ## 0.9.26
 
 Features:

data/README.md

@@ -1,3 +1,5 @@
+### Note: the master branch is currently unstable while 0.10 is being worked on.<br>The current stable version of bundler is in the branch named `v0.9`.
+
 ## Bundler : A gem to bundle gems
 
 Bundler is a tool that manages gem dependencies for your ruby application. It
@@ -120,7 +122,7 @@ When deploying to a server that is memory-constrained, like Dreamhost, you shoul
 
 ### Other questions
 
-Any remaining questions may be asked via IRC in [#carlhuda](irc://irc.freenode.net/carlhuda) on Freenode, or via email on the [Bundler mailing list](http://groups.google.com/group/ruby-bundler).
+Any remaining questions may be asked via IRC in [#bundler](irc://irc.freenode.net/bundler) on Freenode, or via email on the [Bundler mailing list](http://groups.google.com/group/ruby-bundler).
 
 ## Reporting bugs
 

data/ROADMAP.md

@@ -1,51 +1,36 @@
-We will be releasing one more point release (0.10.x) followed by 1.0. While
-the following reflects our current thinking, critical bugs may alter it
-somewhat.
-
-# 0.10
+# 1.0
 
   - No breaking changes to the Gemfile are expected
   - We expect to modify the format of Gemfile.lock.
-    - This should be the final change; it will not change for 1.0
-    - The Gemfile.lock generated by 0.9 will continue to work until 1.0
-    - If you use Bundler 0.10, we will transparently update the format
-    - This means: you will not be able to upgrade a locked app
-     directly from 0.9 to 1.0.
-  - Bundler 0.10 will automatically generate Gemfile.lock when any
+    - This should be the final change
+    - This means you will not be able to upgrade a locked app
+      directly from 0.9 to 1.0.
+  - Bundler will automatically generate Gemfile.lock when any
     resolve is successful.
-  - bundle install will conservatively update Gemfile.lock from the
+    - This means the bundle lock command will no longer be needed.
+  - Bundler will conservatively update Gemfile.lock from the
     last successful resolve if the Gemfile has been modified since
     the last use of bundler.
     - This means that adding a new gem to the Gemfile that does not
-     conflict with existing gems will not force an update of other
-     gems.
+      conflict with existing gems will not force an update of other
+      gems.
     - This also means that we will not force an update to previously
-     resolved dependencies as long as they are compatible with some
-     valid version of the new dependency.
+      resolved dependencies as long as they are compatible with some
+      valid version of the new dependency.
     - When removing a gem, bundle install will simply remove it, without
-     recalculating all dependencies.
+      recalculating all dependencies.
   - We will be adding `bundle update` for the case where you -do-
     wish to re-resolve all dependencies and update everything to the
     latest version.
     - bundle update will also take a gem name, if you want to force
-     an update to just a single gem (and its dependencies).
-  - Add a way to install dependencies that require build options
-  - Add a way to specify groups that are opt-in at install-time,
-    rather than opt-out.
-  - Some additional features that we have tagged for 0.10. For up
-    to date information, please visit
-    http://github.com/carlhuda/bundler/issues/labels/0.10
-
-# 1.0
-
-  - No breaking changes to the Gemfile are expected
-  - No breaking changes to the Gemfile.lock are expected
-  - No major changes to the workflow are expected
-  - Reduce open bug count to 0
+      an update to just a single gem (and its dependencies).
+  - There will be a way to install dependencies that require build options
+  - We will add groups that are opt-in at install-time, rather than opt-out.
+  - We will reduce open bug count to 0 for the final 1.0 release.
   - Some additional features that require more thought. For details,
     see http://github.com/carlhuda/bundler/issues/labels/1.0
 
-# No Breaking changes
+# 1.1
 
-We expect no breaking changes of the Gemfile, Gemfile.lock, or
-basic workflow for 1.x releases.
+  - Stop upgrading 0.9 lockfiles
+  - Delete vestigial gems installed into ~/.bundle/ by 0.9

data/TODO.md

@@ -0,0 +1,16 @@
+## Bundler TODO list
+
+  - Check to make sure ~/.bundler/bin is in $PATH
+  - Cache Git repositories
+  - Interactive mode for bundle (install) to work out conflicts
+  - bundle irb / bundle ruby / bundle [whatever] -> bundle exec
+  - Make bundle (install) work when sudo might be needed
+  - Generate a bundle stub into the application
+  - Handle the following case (no remote fetching):
+    1) Depend on nokogiri, nokogiri is installed locally (ruby platform)
+    2) Run bundle package. nokogiri-1.4.2.gem is cached
+    3) Clone on jruby
+    4) Run `bundle install`
+    Bundler will happily install the RUBY platform nokogiri because it
+    is cached and bundler has not hit the remote source once so it does
+    not know that there is a nokogiri-1.4.2-java.gem available

data/lib/bundler.rb

@@ -5,12 +5,17 @@ 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 :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'
@@ -21,9 +26,6 @@ module Bundler
   autoload :Specification,       'bundler/shared_helpers'
   autoload :UI,                  'bundler/ui'
 
-  GEM_LOADED = true
-  ORIGINAL_ENV = ENV.to_hash
-
   class BundlerError < StandardError
     def self.status_code(code = nil)
       return @code unless code
@@ -37,7 +39,6 @@ module Bundler
 
   class GemfileNotFound  < BundlerError; status_code(10) ; end
   class GemNotFound      < BundlerError; status_code(7)  ; end
-  class VersionConflict  < BundlerError; status_code(6)  ; end
   class GemfileError     < BundlerError; status_code(4)  ; end
   class GemfileChanged   < GemfileError; status_code(4)  ; end
   class PathError        < BundlerError; status_code(13) ; end
@@ -45,8 +46,23 @@ module Bundler
   class GemspecError     < BundlerError; status_code(14) ; end
   class DeprecatedMethod < BundlerError; status_code(12) ; end
   class DeprecatedOption < BundlerError; status_code(12) ; end
+  class GemspecError     < BundlerError; status_code(14) ; end
   class InvalidOption    < BundlerError; status_code(15) ; end
 
+  class VersionConflict  < BundlerError
+    attr_reader :conflicts
+
+    def initialize(conflicts, msg = nil)
+      super(msg)
+      @conflicts = conflicts
+    end
+
+    status_code(6)
+  end
+
+  # Internal errors, should be rescued
+  class InvalidSpecSet < StandardError; end
+
   class << self
     attr_writer :ui, :bundle_path
 
@@ -63,12 +79,20 @@ module Bundler
 
     def bundle_path
       @bundle_path ||= begin
-        path = settings[:path] || "#{Gem.user_home}/.bundle/#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}"
+        path = settings[:path] || Gem.dir
         Pathname.new(path).expand_path(root)
       end
     end
 
-    def gem_setup(*groups)
+    def bin_path
+      @bin_path ||= begin
+        path = settings[:bin] || "#{Gem.user_home}/.bundle/bin"
+        FileUtils.mkdir_p(path)
+        Pathname.new(path).expand_path
+      end
+    end
+
+    def setup(*groups)
       return @setup if @setup
 
       if groups.empty?
@@ -83,35 +107,26 @@ module Bundler
         unloaded.any? ? load.setup(*unloaded) : load
       end
     end
-    alias setup gem_setup unless defined?(Bundler::ENV_LOADED)
 
-    def gem_require(*groups)
+    def require(*groups)
       setup(*groups).require(*groups)
     end
-    alias require gem_require unless defined?(Bundler::ENV_LOADED)
 
     def load
-      @load ||= begin
-        if !update_env_file?
-          Kernel.require env_file
-          Bundler
-        else
-          runtime
-        end
-      end
+      @load ||= Runtime.new(root, definition)
     end
 
-    def runtime
-      @runtime ||= Runtime.new(root, definition)
+    def environment
+      Bundler::Environment.new(root, definition)
     end
 
-    def definition
-      configure
-      lockfile = root.join("Gemfile.lock")
-      if lockfile.exist?
-        Definition.from_lock(lockfile)
-      else
-        Definition.from_gemfile(default_gemfile)
+    def definition(unlock = nil)
+      @definition = nil if unlock
+      @definition ||= begin
+        configure
+        upgrade_lockfile
+        lockfile = root.join("Gemfile.lock")
+        Definition.build(default_gemfile, lockfile, unlock)
       end
     end
 
@@ -132,15 +147,19 @@ module Bundler
     end
 
     def root
-      default_gemfile.dirname
+      default_gemfile.dirname.expand_path
     end
 
-    def settings
-      @settings ||= Settings.new(root)
+    def app_cache
+      root.join("vendor/cache")
+    end
+
+    def tmp
+      "#{Gem.user_home}/.bundler/tmp"
     end
 
-    def env_file
-      SharedHelpers.env_file
+    def settings
+      @settings ||= Settings.new(root)
     end
 
     def with_clean_env
@@ -155,6 +174,22 @@ module Bundler
       SharedHelpers.default_gemfile
     end
 
+    WINDOWS = Config::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw)!
+    NULL    = WINDOWS ? "NUL" : "/dev/null"
+
+    def requires_sudo?
+      case
+      when File.writable?(bundle_path) ||
+           `which sudo 2>#{NULL}`.empty? ||
+           File.owned?(bundle_path)
+        false
+      else
+        true
+      end
+    rescue Errno::ENOENT
+      false
+    end
+
   private
 
     def configure_gem_home_and_path
@@ -170,17 +205,28 @@ module Bundler
       Gem.clear_paths
     end
 
-    def update_env_file?
-      if env_file.exist?
-        outdated = (env_file.read(100) !~ /Bundler #{Bundler::VERSION}/)
-        writable = env_file.writable?
-        if outdated && !writable
-          STDERR.puts "Cannot write to outdated .bundle/environment.rb to update it"
-        end
-        outdated && writable
-      else
-        true
+    def upgrade_lockfile
+      lockfile = root.join("Gemfile.lock")
+      if lockfile.exist? && lockfile.read(3) == "---"
+        Bundler.ui.warn "Detected Gemfile.lock generated by 0.9, deleting..."
+        lockfile.rmtree
+        # lock = YAML.load_file(lockfile)
+        #
+        # source_uris = lock["sources"].map{|s| s["Rubygems"]["uri"] }
+        # sources = [Bundler::Source::Rubygems.new({"remotes" => source_uris})]
+        #
+        # deps = lock["dependencies"].map do |name, opts|
+        #   version = opts.delete("version")
+        #   Bundler::Dependency.new(name, version, opts)
+        # end
+        #
+        # definition = Bundler::Definition.new(nil, deps, sources, {})
+        #
+        # File.open(lockfile, 'w') do |f|
+        #   f.write definition.to_lock
+        # end
       end
     end
+
   end
 end

data/lib/bundler/cli.rb

@@ -7,9 +7,22 @@ Gem.configuration
 
 module Bundler
   class CLI < Thor
+    def initialize(*)
+      super
+      Bundler.ui = UI::Shell.new(shell)
+      Gem::DefaultUserInteraction.ui = UI::RGProxy.new(Bundler.ui)
+    end
+
     check_unknown_options! unless ARGV.include?("exec")
 
+    default_task :install
+
     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
@@ -36,44 +49,46 @@ module Bundler
       end
     end
 
-    def initialize(*)
-      super
-      Bundler.ui = UI::Shell.new(shell)
-      Gem::DefaultUserInteraction.ui = UI::RGProxy.new(Bundler.ui)
-    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
     def check
-      env = Bundler.runtime
-      # Check top level dependencies
-      missing = env.dependencies.select { |d| env.index.search(d).empty? }
-      if missing.any?
-        Bundler.ui.error "The following dependencies are missing"
-        missing.each do |d|
-          Bundler.ui.error "  * #{d}"
-        end
+      not_installed = Bundler.definition.missing_specs
+
+      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
       else
-        not_installed = env.requested_specs.select { |spec| !spec.loaded_from }
-
-        if not_installed.any?
-          not_installed.each { |s| Bundler.ui.error "#{s.name} (#{s.version}) is cached, but not installed" }
-          Bundler.ui.warn "Install missing gems with `bundle install`"
-          exit 1
-        else
-          Bundler.ui.info "The Gemfile's dependencies are satisfied"
-        end
+        Bundler.ui.info "The Gemfile's dependencies are satisfied"
       end
     end
 
     desc "install", "Install the current environment to the system"
-    method_option "without", :type => :array,   :banner => "Exclude gems that are part of the specified named group."
-    method_option "relock",  :type => :boolean, :banner => "Unlock, install the gems, and relock."
-    method_option "disable-shared-gems", :type => :boolean, :banner => "Do not use any shared gems, such as the system gem repository."
-    method_option "gemfile", :type => :string, :banner => "Use the specified gemfile instead of Gemfile"
-    method_option "no-cache",  :type => :boolean, :banner => "Don't update the existing gem cache."
-    method_option "no-prune",  :type => :boolean, :banner => "Don't remove stale gems from the cache."
+    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 "disable-shared-gems", :type => :boolean, :banner =>
+      "Do not use any shared gems, such as the system gem repository."
+    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."
     def install(path = nil)
       opts = options.dup
       opts[:without] ||= []
@@ -82,62 +97,61 @@ module Bundler
       # Can't use Bundler.settings for this because settings needs gemfile.dirname
       ENV['BUNDLE_GEMFILE'] = opts[:gemfile] if opts[:gemfile]
       Bundler.settings[:path] = path if path
-      Bundler.settings[:disable_shared_gems] = '1' if options["disable-shared-gems"]
+      Bundler.settings[:disable_shared_gems] = '1' if options["disable-shared-gems"] || path
       Bundler.settings.without = opts[:without]
 
-      remove_lockfiles if options[:relock]
-
-      begin
-        Installer.install(Bundler.root, Bundler.definition, opts)
-      rescue GemfileChanged
-        raise GemfileChanged, "You changed your Gemfile after locking. " +
-          "Please run `bundle install --relock`."
-      end
-
-      lock if options[:relock]
-      cache if Bundler.root.join("vendor/cache").exist? && !options[:no_cache]
+      Installer.install(Bundler.root, Bundler.definition, opts)
+      cache if Bundler.root.join("vendor/cache").exist?
       Bundler.ui.confirm "Your bundle is complete! " +
         "Use `bundle show [gemname]` to see where a bundled gem is installed."
     rescue GemNotFound => e
-      if Bundler.definition.sources.empty?
+      if Bundler.definition.no_sources?
         Bundler.ui.warn "Your Gemfile doesn't have any sources. You can add one with a line like 'source :gemcutter'"
       end
       raise e
     end
 
-    desc "lock", "Locks the bundle to the current set of dependencies, including all child dependencies."
-    def lock
-      if locked?
-        Bundler.ui.info("Your bundle is already locked, relocking.")
-        remove_lockfiles
+    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)"
+    def update(*gems)
+      sources = Array(options[:source])
+
+      if gems.empty? && sources.empty?
+        # We're doing a full update
+        FileUtils.rm Bundler.root.join("Gemfile.lock")
+      else
+        Bundler.definition(:gems => gems, :sources => sources)
       end
 
-      Bundler.runtime.lock
-      Bundler.ui.confirm("Your bundle is now locked. " +
-        "Use `bundle show [gemname]` to list the gems in the environment.")
-    rescue GemNotFound, VersionConflict => e
-      Bundler.ui.error(e.message)
-      Bundler.ui.warn "Run `bundle install` to install missing gems."
-      exit 128
+      Installer.install Bundler.root, Bundler.definition
+    end
+
+    desc "lock", "Locks the bundle to the current set of dependencies, including all child dependencies."
+    def lock
+      Bundler.ui.warn "Lock is deprecated. Your bundle is now locked whenever you run `bundle install`."
     end
 
     desc "unlock", "Unlock the bundle. This allows gem versions to be changed."
     def unlock
-      if locked?
-        remove_lockfiles
-        Bundler.ui.info("Your bundle is now unlocked. The dependencies may be changed.")
-      else
-        Bundler.ui.info("Your bundle is not currently locked.")
-      end
+      Bundler.ui.warn "Unlock is deprecated. To update to newer gem versions, use `bundle update`."
     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
     def show(gem_name = nil)
       if gem_name
         Bundler.ui.info locate_gem(gem_name)
       else
         Bundler.ui.info "Gems included by the bundle:"
-        Bundler.runtime.specs.sort_by { |s| s.name }.each do |s|
+        Bundler.load.specs.sort_by { |s| s.name }.each do |s|
           Bundler.ui.info "  * #{s.name} (#{s.version}#{s.git_version})"
         end
       end
@@ -147,8 +161,8 @@ module Bundler
     desc "cache", "Cache all the gems to vendor/cache"
     method_option "no-prune",  :type => :boolean, :banner => "Don't remove stale gems from the cache."
     def cache
-      Bundler.runtime.cache
-      Bundler.runtime.prune_cache unless options[:no_prune]
+      Bundler.load.cache
+      Bundler.load.prune_cache unless options[:no_prune]
     rescue GemNotFound => e
       Bundler.ui.error(e.message)
       Bundler.ui.warn "Run `bundle install` to install missing gems."
@@ -157,13 +171,25 @@ module Bundler
 
     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."
+    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
-      lock
+      install
+      # TODO: move cache contents here now that all bundles are locked
       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.delete("exec")
 
@@ -185,7 +211,7 @@ module Bundler
 
       begin
         # Run
-        Kernel.exec *ARGV
+        Kernel.exec(*ARGV)
       rescue Errno::EACCES
         Bundler.ui.error "bundler: not executable: #{ARGV.first}"
       rescue Errno::ENOENT
@@ -222,19 +248,35 @@ module Bundler
     end
     map %w(-v --version) => :version
 
-  private
+    desc 'viz', "Generates a visual dependency graph"
+    method_option :file, :type => :string, :default => 'gem_graph.png', :aliases => '-f', :banner => "Show the version with each gem name."
+    method_option :version, :type => :boolean, :default => false, :aliases => '-v', :banner => "Show the version with each gem name."
+    method_option :requirements, :type => :boolean, :default => false, :aliases => '-r', :banner => "Show the requirement for each dependency."
+    def viz
+      output_file = File.expand_path(options[:file])
+      graph = Graph.new( Bundler.load )
 
-    def locked?
-      File.exist?("#{Bundler.root}/Gemfile.lock") || File.exist?("#{Bundler.root}/.bundle/environment.rb")
+      begin
+        graph.viz(output_file, options[:version], options[:requirements])
+        Bundler.ui.info output_file
+      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
 
-    def remove_lockfiles
-      FileUtils.rm_f "#{Bundler.root}/Gemfile.lock"
-      FileUtils.rm_f "#{Bundler.root}/.bundle/environment.rb"
-    end
+  private
 
     def locate_gem(name)
-      spec = Bundler.runtime.specs.find{|s| s.name == name }
+      spec = Bundler.load.specs.find{|s| s.name == name }
       raise GemNotFound, "Could not find gem '#{name}' in the current bundle." unless spec
       spec.full_gem_path
     end