bundler 0.9.0.pre3 → 0.9.0.pre4

data/README.markdown

@@ -0,0 +1,152 @@
+## 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 bundle's gems accordingly. It also lets
+you run any ruby code in context of the bundle's gem environment.
+
+## Installation
+
+Bundler has no dependencies besides Ruby and RubyGems. 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 --prerelease
+    
+## Usage
+
+The first thing to do is create a gem manifest file named `Gemfile` at the
+root directory of your application. This can quickly be done by running
+`bundle init` in the directory that you wish the Gemfile to be created in.
+
+### Gemfile
+
+This is where you specify all of your application's dependencies. The
+following is an example. For more information, refer to
+Bundler::Dsl.
+
+    # Add :gemcutter as a source that Bundler will use
+    # to find gems listed in the manifest. At least one source
+    # should be listed. URLs maybe also be used, such as
+    # http://gems.github.com.
+    #
+    source :gemcutter
+
+    # Specify a dependency on rails. When 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"
+
+### Installing gems
+
+Once the manifest file has been created, the next step is to install all
+the gems needed to satisfy the Gemfile's dependencies. The `bundle install`
+command will do this.
+
+This command will load the Gemfile, resolve all the dependencies, download
+all gems that are missing, and install them to the system's RubyGems
+repository. Every time an update is made to the Gemfile, run `bundle install`
+again to get the new gems installed.
+
+### Locking dependencies
+
+By default, bundler will only ensure that the activated gems satisfy the
+Gemfile's dependencies. If you install a newer version of a gem and it
+satisfies the dependencies, it will be used instead of the older one. 
+
+The command `bundle lock` will lock the bundle to the current set of
+resolved gems. This ensures that, until the lock file is removed, that
+bundle install and Bundle.setup will always activate the same gems.
+
+### Running the application
+
+Bundler must be required and setup before anything else is required. This
+is because it will configure all the load paths and manage rubygems for your.
+To do this, include the following at the beginning of your code.
+
+    begin
+      # Require the preresolved locked set of gems.
+      require File.expand_path('../vendor/environment', __FILE__)
+    rescue LoadError
+      # Fallback on doing the resolve at runtime.
+      require "rubygems"
+      require "bundler"
+      Bundler.setup
+    end
+
+    # Your application requires come here
+
+The `bundle exec` command provides a way to run arbitrary ruby code in
+context of the bundle. For example:
+
+    bundle exec ruby my_ruby_script.rb
+
+To enter a shell that will run all gem executables (such as rake, rails,
+etc... ) use `bundle exec bash` (replacing bash for whatever your favorite
+shell is).
+
+### Packing the bundle's gems
+
+When sharing or deploying an application, it might be useful to include
+everything necessary to install gem dependencies. `bundle pack` will
+copy .gem files for all of the bundle's dependencies into vendor/cache.
+This way, bundle install can always work no matter what the state of the
+remote sources.
+
+## 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".
+
+## Reporting bugs
+
+Please report all bugs on the github issue tracker for the project located
+at:
+
+    http://github.com/wycats/bundler/issues/

data/bin/bundle

@@ -1,3 +1,8 @@
 require 'bundler/cli'
 
-Bundler::CLI.start
+begin
+  Bundler::CLI.start
+rescue Bundler::BundlerError => e
+  puts e.message
+  exit e.status_code
+end

data/lib/bundler.rb

@@ -4,7 +4,7 @@ require 'yaml'
 require 'bundler/rubygems'
 
 module Bundler
-  VERSION = "0.9.0.pre3"
+  VERSION = "0.9.0.pre4"
 
   autoload :Definition,          'bundler/definition'
   autoload :Dependency,          'bundler/dependency'
@@ -18,67 +18,108 @@ module Bundler
   autoload :Specification,       'bundler/specification'
   autoload :UI,                  'bundler/ui'
 
-  class GemfileNotFound < StandardError; end
-  class GemNotFound     < StandardError; end
-  class VersionConflict < StandardError; end
-  class GemfileError    < StandardError; end
+  class BundlerError < StandardError
+    def self.status_code(code = nil)
+      return @code unless code
+      @code = code
+    end
 
-  def self.ui
-    @ui ||= UI.new
+    def status_code
+      self.class.status_code
+    end
   end
 
-  def self.ui=(ui)
-    @ui = ui
-  end
+  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
 
-  def self.setup(*groups)
-    gemfile = default_gemfile
-    load(gemfile).setup(*groups)
-  end
+  class << self
+    attr_writer :ui, :bundle_path
 
-  def self.load(gemfile = default_gemfile)
-    root = Pathname.new(gemfile).dirname
-    Environment.new root, definition(gemfile)
-  end
+    def configure
+      @configured ||= begin
+        point_gem_home(env[:bundle_path])
+        true
+      end
+    end
 
-  def self.definition(gemfile = default_gemfile)
-    root = Pathname.new(gemfile).dirname
-    lockfile = root.join("vendor/lock.yml")
-    if lockfile.exist?
-      Definition.from_lock(lockfile)
-    else
-      Definition.from_gemfile(gemfile)
+    def ui
+      @ui ||= UI.new
     end
-  end
 
-  def self.home
-    Pathname.new(Gem.dir).join("bundler")
-  end
+    def bundle_path
+      @bundle_path ||= Pathname.new(env[:bundle_path] || Gem.dir)
+    end
 
-  def self.install_path
-    home.join("gems")
-  end
+    def setup(*groups)
+      gemfile = default_gemfile
+      load(gemfile).setup(*groups)
+    end
 
-  def self.cache
-    home.join("cache")
-  end
+    def load(gemfile = default_gemfile)
+      root = Pathname.new(gemfile).dirname
+      Environment.new root, definition(gemfile)
+    end
 
-  def self.root
-    default_gemfile.dirname
-  end
+    def definition(gemfile = default_gemfile)
+      configure
+      root = Pathname.new(gemfile).dirname
+      lockfile = root.join("Gemfile.lock")
+      if lockfile.exist?
+        Definition.from_lock(lockfile)
+      else
+        Definition.from_gemfile(gemfile)
+      end
+    end
 
-private
+    def home
+      Pathname.new(bundle_path).join("bundler")
+    end
 
-  def self.default_gemfile
-    current = Pathname.new(Dir.pwd)
+    def install_path
+      home.join("gems")
+    end
 
-    until current.root?
-      filename = current.join("Gemfile")
-      return filename if filename.exist?
-      current = current.parent
+    def cache
+      home.join("cache")
     end
 
-    raise GemfileNotFound, "The default Gemfile was not found"
-  end
+    def root
+      default_gemfile.dirname
+    end
+
+  private
+
+    def default_gemfile
+      current = Pathname.new(Dir.pwd)
 
+      until current.root?
+        filename = current.join("Gemfile")
+        return filename if filename.exist?
+        current = current.parent
+      end
+
+      raise GemfileNotFound, "The default Gemfile was not found"
+    end
+
+    def env
+      @env ||= begin
+        env    = {}
+        file   = "#{root}/.bundleconfig"
+        config = File.exist?(file) ? YAML.load_file(file) : {}
+        %w(BUNDLE_PATH).each do |key|
+          env[key.downcase.to_sym] = config[key] || ENV[key]
+        end
+        env
+      end
+    end
+
+    def point_gem_home(path)
+      return unless path
+      ENV['GEM_HOME'] = File.expand_path(path, root)
+      ENV['GEM_PATH'] = ''
+      Gem.clear_paths
+    end
+  end
 end

data/lib/bundler/cli.rb

@@ -32,22 +32,18 @@ module Bundler
 
     desc "check", "Checks if the dependencies listed in Gemfile are satisfied by currently installed gems"
     def check
-      with_rescue do
-        env = Bundler.load
-        # Check top level dependencies
-        missing = env.dependencies.select { |d| env.index.search(d).empty? }
-        if missing.any?
-          puts "The following dependencies are missing"
-          missing.each do |d|
-            puts "  * #{d}"
-          end
-        else
-          env.specs
-          puts "The Gemfile's dependencies are satisfied"
+      env = Bundler.load
+      # Check top level dependencies
+      missing = env.dependencies.select { |d| env.index.search(d).empty? }
+      if missing.any?
+        puts "The following dependencies are missing"
+        missing.each do |d|
+          puts "  * #{d}"
         end
+      else
+        env.specs
+        puts "The Gemfile's dependencies are satisfied"
       end
-    rescue VersionConflict => e
-      puts e.message
     end
 
     desc "install", "Install the current environment to the system"
@@ -58,17 +54,23 @@ module Bundler
       opts[:without].map! { |g| g.to_sym }
 
       Installer.install(Bundler.root, Bundler.definition, opts)
-    rescue Bundler::GemNotFound => e
-      puts e.message
-      exit 1
     end
 
-    desc "lock", "Locks a resolve"
+    desc "lock", "Locks the bundle to the current set of dependencies, including all child dependencies."
     def lock
       environment = Bundler.load
       environment.lock
     end
 
+    desc "show", "Shows all gems that are part of the bundle."
+    def show
+      environment = Bundler.load
+      Bundler.ui.info "Gems included by the bundle:"
+      environment.specs.sort_by { |s| s.name }.each do |s|
+        Bundler.ui.info "  * #{s.name} (#{s.version})"
+      end
+    end
+
     desc "pack", "Packs all the gems to vendor/cache"
     def pack
       environment = Bundler.load
@@ -86,13 +88,5 @@ module Bundler
       Kernel.exec *ARGV
     end
 
-  private
-
-    def with_rescue
-      yield
-    rescue GemfileNotFound => e
-      puts e.message
-      exit 1
-    end
   end
 end

data/lib/bundler/definition.rb

@@ -28,14 +28,14 @@ module Bundler
 
     def local_index
       @local_index ||= begin
-        index = Index.from_installed_gems
+        index = Index.new
 
         sources.each do |source|
           next unless source.respond_to?(:local_specs)
           index = source.local_specs.merge(index)
         end
 
-        index
+        Index.from_installed_gems.merge(index)
       end
     end
 

data/lib/bundler/dsl.rb

@@ -23,23 +23,23 @@ module Bundler
       @dependencies << Dependency.new(name, version, options)
     end
 
-    def source(source)
+    def source(source, options = {})
       source = case source
       when :gemcutter, :rubygems, :rubyforge then Source::Rubygems.new(:uri => "http://gemcutter.org")
       when String then Source::Rubygems.new(:uri => source)
       else source
       end
 
-      @sources << source
+      options[:prepend] ? @sources.unshift(source) : @sources << source
       source
     end
 
     def path(path, options = {})
-      source Source::Path.new(options.merge(:path => path))
+      source Source::Path.new(options.merge(:path => path)), options
     end
 
     def git(uri, options = {})
-      source Source::Git.new(options.merge(:uri => uri))
+      source Source::Git.new(options.merge(:uri => uri)), options
     end
 
     def to_definition
@@ -66,17 +66,14 @@ module Bundler
 
       opts["group"] ||= @group
 
-      _normalize_git_options(name, version, opts)
-    end
-
-    def _normalize_git_options(name, version, opts)
-      # Normalize Git options
-      if opts["git"]
-        source  = git(opts["git"], :ref => opts["ref"])
-        source.default_spec name, version if _version?(version)
-        opts["source"] = source
+      # Normalize git and path options
+      ["git", "path"].each do |type|
+        if param = opts[type]
+          source = send(type, param, opts.merge(:prepend => true))
+          source.default_spec name, version if _version?(version)
+          opts["source"] = source
+        end
       end
     end
-
   end
 end

data/lib/bundler/environment.rb

@@ -24,9 +24,15 @@ module Bundler
     end
 
     def lock
+      Bundler.ui.info("The bundle is already locked, relocking.")
       FileUtils.mkdir_p("#{root}/vendor")
       write_yml_lock
       write_rb_lock
+      Bundler.ui.info("The bundle is locked. Use `bundle show` to list the gems in the environment.")
+    end
+
+    def locked?
+      File.exist?("#{root}/Gemfile.lock")
     end
 
     def specs_for(*groups)
@@ -48,6 +54,8 @@ module Bundler
       end
     end
 
+    alias gems specs
+
     def index
       @definition.local_index
     end
@@ -56,10 +64,12 @@ module Bundler
       pack_path = "#{root}/vendor/cache/"
       FileUtils.mkdir_p(pack_path)
 
+      Bundler.ui.info "Copying .gem files into vendor/cache"
       specs.each do |spec|
-        next if spec.source && !spec.source.is_a?(Source::Rubygems)
+        next unless spec.source.is_a?(Source::SystemGems) || spec.source.is_a?(Source::Rubygems)
         possibilities = Gem.path.map { |p| "#{p}/cache/#{spec.full_name}.gem" }
         cached_path = possibilities.find { |p| File.exist? p }
+        Bundler.ui.info "  * #{File.basename(cached_path)}"
         FileUtils.cp(cached_path, pack_path)
       end
     end
@@ -110,7 +120,7 @@ module Bundler
 
     def write_yml_lock
       yml = details.to_yaml
-      File.open("#{root}/vendor/lock.yml", 'w') do |f|
+      File.open("#{root}/Gemfile.lock", 'w') do |f|
         f.puts yml
       end
     end

data/lib/bundler/index.rb

@@ -1,14 +1,7 @@
 module Bundler
   class Index
     def self.from_installed_gems
-      # TODO: Why can't we memoize this? It is being mutated somewhere
-      from_gem_index(Gem::SourceIndex.from_installed_gems)
-    end
-
-    def self.from_gem_index(gem_index)
-      index = new
-      gem_index.each { |name, spec| index << spec }
-      index
+      Source::SystemGems.new.specs
     end
 
     def initialize

data/lib/bundler/installer.rb

@@ -19,9 +19,12 @@ module Bundler
         return
       end
 
-      specs.each do |spec|
-        next unless spec.source.respond_to?(:install)
-        next if (spec.groups & options[:without]).any?
+      specs.sort_by { |s| s.name }.each do |spec|
+        Bundler.ui.info "* #{spec.name} (#{spec.version})"
+        if (spec.groups & options[:without]).any?
+          Bundler.ui.info "  * Not in requested group... skipping."
+          next
+        end
         spec.source.install(spec)
       end
 

data/lib/bundler/source.rb

@@ -19,12 +19,6 @@ module Bundler
       end
 
       def install(spec)
-        Bundler.ui.info "* #{spec.name} (#{spec.version})"
-        if Index.from_installed_gems[spec].any?
-          Bundler.ui.info "  * already installed... skipping"
-          return
-        end
-
         destination = Gem.dir
 
         Bundler.ui.info "  * Downloading..."
@@ -66,6 +60,29 @@ module Bundler
       end
     end
 
+    class SystemGems
+      def specs
+        @specs ||= begin
+          index = Index.new
+
+          Gem::SourceIndex.from_installed_gems.each do |name, spec|
+            spec.source = self
+            index << spec
+          end
+
+          index
+        end
+      end
+
+      def to_s
+        "System gem source"
+      end
+
+      def install(spec)
+        Bundler.ui.info "  * already installed... skipping"
+      end
+    end
+
     class GemCache
       def initialize(options)
         @path = options[:path]
@@ -88,6 +105,7 @@ module Bundler
       def install(spec)
         destination = Gem.dir
 
+        Bundler.ui.info "  * Installing from pack..."
         installer = Gem::Installer.new "#{@path}/#{spec.full_name}.gem",
           :install_dir => Gem.dir,
           :ignore_dependencies => true
@@ -124,7 +142,9 @@ module Bundler
           if File.directory?(path)
             Dir["#{path}/#{@glob}"].each do |file|
               file = Pathname.new(file)
-              if spec = eval(File.read(file))
+              # Do it in the root of the repo in case they do
+              # assume being in the root
+              if spec = Dir.chdir(path) { eval(File.read(file)) }
                 spec = Specification.from_gemspec(spec)
                 spec.loaded_from = file
                 spec.source      = self
@@ -139,6 +159,10 @@ module Bundler
         end
       end
 
+      def install(spec)
+        Bundler.ui.info "  * Using path `#{path}`..."
+      end
+
       alias specs local_specs
 
     end
@@ -196,7 +220,12 @@ module Bundler
       end
 
       def install(spec)
-        @installed ||= begin
+        Bundler.ui.info "  * Using git `#{uri}`..."
+
+        if @installed
+          Bundler.ui.info "  * Already checked out revision: #{ref}..."
+        else
+          Bundler.ui.info "  * Checking out revision: #{ref}..."
           FileUtils.mkdir_p(path)
           Dir.chdir(path) do
             unless File.exist?(".git")
@@ -207,7 +236,7 @@ module Bundler
             %x(git submodule init)
             %x(git submodule update)
           end
-          true
+          @installed = true
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bundler
 version: !ruby/object:Gem::Version 
-  version: 0.9.0.pre3
+  version: 0.9.0.pre4
 platform: ruby
 authors: 
 - Carl Lerche
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-31 00:00:00 -08:00
+date: 2010-02-02 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -70,7 +70,7 @@ files:
 - lib/bundler/vendor/thor.rb
 - lib/bundler.rb
 - LICENSE
-- README
+- README.markdown
 has_rdoc: true
 homepage: http://github.com/carlhuda/bundler
 licenses: []

data/README

@@ -1,7 +0,0 @@
-This is a rewrite of bundler to offer more bundling power
-
-It currently lacks output and good exception handling for common cases. This is coming very soon. We wanted to open this so people could take a look at it.
-
-More soon.
-
-- carlhuda