bundler 0.8.1 → 0.9.0

data/README.markdown

@@ -9,108 +9,110 @@
 Bundler is a tool that manages gem dependencies for your ruby application. It
 takes a gem manifest file and is able to fetch, download, and install the gems
 and all child dependencies specified in this manifest. It can manage any update
-to the gem manifest file and update the bundled gems accordingly. It also lets
-you run any ruby code in context of the bundled gem environment.
+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. Just clone the git repository and install the gem
-with the following rake task:
+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
-
+    gem install bundler --prerelease
+    
 ## Usage
 
-Bundler requires a gem manifest file to be created. This should be a file named
-`Gemfile` located in the root directory of your application. After the manifest
-has been created, in your shell, cd into your application's directory and run
-`gem bundle`. This will start the bundling process.
+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
 
-### Manifest file
+This is where you specify all of your application's dependencies. The
+following is an example. For more information, refer to
+Bundler::Dsl.
 
-This is where you specify all of your application's dependencies. By default
-this should be in a file named `Gemfile` located in your application's root
-directory. The following is an example of a potential `Gemfile`. For more
-information, please refer to Bundler::ManifestBuilder.
+    # 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 the bundler downloads gems,
-    # it will download rails as well as all of rails' dependencies (such as
-    # activerecord, actionpack, etc...)
+    # 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.
+    # Specify a dependency on rack v.1.0.0. The version is optional.
+    # If present, it can be specified the same way as with rubygems'
+    # #gem method.
+    #
     gem "rack", "1.0.0"
 
-    # Specify a dependency rspec, but only require that gem in the "testing"
-    # environment. :except is also a valid option to specify environment
-    # restrictions.
-    gem "rspec", :only => :testing
+### Installing gems
 
-    # Specify a dependency, but specify that it is already present and expanded
-    # at vendor/rspec. Bundler will treat rspec as though it was the rspec gem
-    # for the purpose of gem resolution: if another gem depends on a version
-    # of rspec satisfied by "1.1.6", it will be used.
-    #
-    # If a gemspec is found in the directory, it will be used to specify load
-    # paths and supply additional dependencies.
-    #
-    # Bundler will also recursively search for *.gemspec, and assume that
-    # gemspecs it finds represent gems that are rooted in the same directory
-    # the gemspec is found in.
-    gem "rspec", "1.1.6", :vendored_at => "vendor/rspec"
+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.
 
-    # You can also control what will happen when you run Bundler.require_env
-    # by using the :require_as option, as per the next two examples.
+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.
 
-    # Don't auto-require this gem.
-    gem "rspec-rails", "1.2.9", :require_as => nil
+### Locking dependencies
 
-    # Require something other than the default.
-    gem "yajl-ruby", "0.6.7", :require_as => "yajl/json_gem"
+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. 
 
-    # Works exactly like :vendored_at, but first downloads the repo from
-    # git and handles stashing the files for you. As with :vendored_at,
-    # Bundler will automatically use *.gemspec files in the root or anywhere
-    # in the repository.
-    gem "rails", "3.0.pre", :git => "git://github.com/rails/rails.git"
+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.
 
-    # Add http://gems.github.com as a source that the bundler will use
-    # to find gems listed in the manifest. By default,
-    # http://gems.rubyforge.org is already added to the list.
-    #
-    # This is an optional setting.
-    source "http://gems.github.com"
+### Running the application
 
-    # Specify where the bundled gems should be stashed. This directory will
-    # be a gem repository where all gems are downloaded to and installed to.
-    #
-    # This is an optional setting.
-    # The default is: vendor/gems
-    bundle_path "my/bundled/gems"
+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.
 
-    # Specify where gem executables should be copied to.
-    #
-    # This is an optional setting.
-    # The default is: bin
-    bin_path "my/executables"
+    begin
+      # Require the preresolved locked set of gems.
+      require File.expand_path('../.bundle/environment', __FILE__)
+    rescue LoadError
+      # Fallback on doing the resolve at runtime.
+      require "rubygems"
+      require "bundler"
+      Bundler.setup
+    end
 
-    # Specify that rubygems should be completely disabled. This means that it
-    # will be impossible to require it and that available gems will be
-    # limited exclusively to gems that have been bundled.
-    #
-    # The default is to automatically require rubygems. There is also a
-    # `disable_system_gems` option that will limit available rubygems to
-    # the ones that have been bundled.
-    disable_rubygems
+    # 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
 
-### Gem Resolution
+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
@@ -142,143 +144,9 @@ a more narrow dependency.
 Bundler solves this problem by evaluating all dependencies at once,
 so it can detect that all gems *together* require activesupport "2.3.4".
 
-### Running Bundler
-
-Once a manifest file has been created, the only thing that needs to be done
-is to run the `gem bundle` command anywhere in your application. The script
-will load the manifest file, resolve all the dependencies, download all
-needed gems, and install them into the specified directory.
-
-Every time an update is made to the manifest file, run `gem bundle` again to
-get the changes installed. This will only check the remote sources if your
-currently installed gems do not satisfy the `Gemfile`. If you want to force
-checking for updates on the remote sources, use the `--update` option.
-
-### Remote deploys
-
-When you run `gem bundle`, the following steps occur:
-
-1. Gemfile is read in
-2. The gems specified in the Gemfile are resolved against the gems
-   already in your bundle. If the dependencies resolve, skip to step 5.
-3. If the dependencies in your Gemfile cannot be fully resolved
-   against the gems already in the bundle, the metadata for each
-   source is fetched.
-4. The gems in the Gemfile are resolved against the full list of
-   available gems in all sources, and the resulting gems are downloaded
-5. Each gem that has been downloaded but not yet expanded is expanded
-   into the local directory. This expansion process also installs
-   native gems.
-
-As you can see, if you run gem bundle twice in a row, it will do nothing the
-second time, since the gems obviously resolve against the installed gems,
-and they are all expanded.
-
-This also means that if you run `gem bundle`, and .gitignore the expanded
-copies, leaving only the cached `.gem` files, you can run `gem bundle` again
-on the remote system, and it will only expand out the gems (but not
-resolve or download `.gem` files). This also means that native gems
-will be compiled for the target platform without requiring that the
-`.gem` file itself be downloaded from a remote gem server.
-
-Assuming a Rails app with Bundler's standard setup, add something like
-this to your top-level `.gitignore` to only keep the cache:
-
-    bin/*
-    vendor/gems/*
-    !vendor/gems/cache/
-
-Make sure that you explicitly `git add vendor/gems/cache` before you commit.
-
-### Gems with compile-time options
-
-Some gems require you to pass compile-time options to the gem install command.
-For instance, to install mysql, you might do:
-
-    gem install mysql -- --with-mysql-config=/usr/local/lib/mysql
-
-You can pass these options to the bundler by creating a YAML file containing
-the options in question:
-
-    mysql:
-      mysql-config: /usr/local/lib/mysql
-
-You can then point the bundler at the file:
-
-    gem bundle --build-options build_options.yml
-
-In general, you will want to keep the build options YAML out of version control,
-and provide the appropriate options for the system in question.
-
-### Running your application
-
-The easiest way to run your application is to start it with an executable
-copied to the specified bin directory (by default, simply bin). For example,
-if the application in question is a rack app, start it with `bin/rackup`.
-This will automatically set the gem environment correctly.
-
-Another way to run arbitrary ruby code in context of the bundled gems is to
-run it with the `gem exec` command. For example:
-
-    gem exec ruby my_ruby_script.rb
-
-You can use `gem exec bash` to enter a shell that will run all binaries in
-the current context.
-
-Yet another way is to manually require the environment file first. This is
-located in `[bundle_path]/gems/environment.rb`. For example:
-
-    ruby -r vendor/gems/environment.rb my_ruby_script.rb
-
-### Using Bundler with Rails today
-
-It should be possible to use Bundler with Rails today. Here are the steps
-to follow.
-
-* In your rails app, create a Gemfile and specify the gems that your
-  application depends on. Make sure to specify rails as well:
-
-        gem "rails", "2.1.2"
-        gem "will_paginate"
-
-        # Optionally, you can disable system gems all together and only
-        # use bundled gems.
-        disable_system_gems
-
-* Run `gem bundle`
-
-* You can now use rails if you prepend `gem exec` to every call to `script/*`
-  but that isn't fun.
-
-* At the top of `config/preinitializer.rb`, add the following line:
-
-    require "#{RAILS_ROOT}/vendor/gems/environment"
-
-In theory, this should be enough to get going.
-
-## To require rubygems or not
-
-Ideally, no gem would assume the presence of rubygems at runtime. Rubygems provides
-enough features so that this isn't necessary. However, there are a number of gems
-that require specific rubygems features.
-
-If the `disable_rubygems` option is used, Bundler will stub out the most common
-of these features, but it is possible that things will not go as intended quite
-yet. So, if you are brave, try your code without rubygems at runtime.
-
-This is different from the `disable_system_gems` option, which uses the rubygems
-library, but prevents system gems from being loaded; only gems that are bundled
-will be available to your application. This option guarantees that dependencies
-of your application will be available to a remote system.
-
-## Known Issues
-
-* When a gem points to a git repository, the git repository will be cloned
-  every time Bundler does a gem dependency resolve.
-
 ## Reporting bugs
 
 Please report all bugs on the github issue tracker for the project located
 at:
 
-    http://github.com/wycats/bundler/issues/
+    http://github.com/wycats/bundler/issues/

data/bin/bundle

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

data/lib/bundler/cli.rb

@@ -1,88 +1,95 @@
-require "optparse"
+$:.unshift File.expand_path('../vendor', __FILE__)
+require 'thor'
+require 'bundler'
+require 'rubygems/config_file'
+
+# Work around a RubyGems bug
+Gem.configuration
 
 module Bundler
-  class CLI
-    def self.run(command, options = {})
-      new(options).run(command)
-    rescue DefaultManifestNotFound => e
-      Bundler.logger.error "Could not find a Gemfile to use"
-      exit 3
-    rescue InvalidEnvironmentName => e
-      Bundler.logger.error "Gemfile error: #{e.message}"
-      exit 4
-    rescue InvalidRepository => e
-      Bundler.logger.error e.message
-      exit 5
-    rescue VersionConflict => e
-      Bundler.logger.error e.message
-      exit 6
-    rescue GemNotFound => e
-      Bundler.logger.error e.message
-      exit 7
-    rescue InvalidCacheArgument => e
-      Bundler.logger.error e.message
-      exit 8
-    rescue SourceNotCached => e
-      Bundler.logger.error e.message
-      exit 9
-    rescue ManifestFileNotFound => e
-      Bundler.logger.error e.message
-      exit 10
-    end
+  class CLI < Thor
+    ARGV = ::ARGV.dup
 
-    def initialize(options)
-      Bundler.mode = options[:cached] ? :local : :readwrite
-      @options = options
-      @bundle = Bundle.load(@options[:manifest])
+    desc "init", "Generates a Gemfile into the current working directory"
+    def init
+      if File.exist?("Gemfile")
+        puts "Gemfile already exists at #{Dir.pwd}/Gemfile"
+      else
+        puts "Writing new Gemfile to #{Dir.pwd}/Gemfile"
+        FileUtils.cp(File.expand_path('../templates/Gemfile', __FILE__), 'Gemfile')
+      end
     end
 
-    def bundle
-      @bundle.install(@options)
+    def initialize(*)
+      super
+      Bundler.ui = UI::Shell.new(shell)
+      Gem::DefaultUserInteraction.ui = UI::RGProxy.new(Bundler.ui)
     end
 
-    def cache
-      gemfile = @options[:cache]
-
-      if File.extname(gemfile) == ".gem"
-        if !File.exist?(gemfile)
-          raise InvalidCacheArgument, "'#{gemfile}' does not exist."
-        end
-        @bundle.cache(gemfile)
-      elsif File.directory?(gemfile) || gemfile.include?('/')
-        if !File.directory?(gemfile)
-          raise InvalidCacheArgument, "'#{gemfile}' does not exist."
+    desc "check", "Checks if the dependencies listed in Gemfile are satisfied by currently installed gems"
+    def check
+      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
-        gemfiles = Dir["#{gemfile}/*.gem"]
-        if gemfiles.empty?
-          raise InvalidCacheArgument, "'#{gemfile}' contains no gemfiles"
-        end
-        @bundle.cache(*gemfiles)
       else
-        raise InvalidCacheArgument, "w0t? '#{gemfile}' means nothing to me."
+        env.specs
+        puts "The Gemfile's dependencies are satisfied"
       end
     end
 
-    def prune
-      Bundler.mode = :local
-      @bundle.prune(@options)
+    desc "install", "Install the current environment to the system"
+    method_option :without, :type => :array, :banner => "Exclude gems thar are part of the specified named group"
+    def install(path = nil)
+      opts = options.dup
+      opts[:without] ||= []
+      opts[:without].map! { |g| g.to_sym }
+
+      Bundler.settings[:path] = path if path
+
+      Installer.install(Bundler.root, Bundler.definition, opts)
+    end
+
+    desc "lock", "Locks the bundle to the current set of dependencies, including all child dependencies."
+    def lock
+      environment = Bundler.load
+      environment.lock
     end
 
-    def list
-      @bundle.list(@options)
+    desc "unlock", "Unlock the bundle. This allows gem versions to be changed"
+    def unlock
+      environment = Bundler.load
+      environment.unlock
     end
 
-    def list_outdated
-      @bundle.list_outdated(@options)
+    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
 
-    def exec
-      @bundle.setup_environment
-      # w0t?
-      super(*$command)
+    desc "pack", "Packs all the gems to vendor/cache"
+    def pack
+      environment = Bundler.load
+      environment.pack
     end
 
-    def run(command)
-      send(command)
+    desc "exec", "Run the command in context of the bundle"
+    def exec(*)
+      ARGV.delete('exec')
+      ENV["RUBYOPT"] = %W(
+        -I#{File.expand_path('../..', __FILE__)}
+        -rbundler/setup
+        #{ENV["RUBYOPT"]}
+      ).compact.join(' ')
+      Kernel.exec *ARGV
     end
 
   end

data/lib/bundler/definition.rb

@@ -0,0 +1,80 @@
+module Bundler
+  class Definition
+    def self.from_gemfile(gemfile)
+      gemfile = Pathname.new(gemfile).expand_path
+
+      unless gemfile.file?
+        raise GemfileNotFound, "#{gemfile} not found"
+      end
+
+      Dsl.evaluate(gemfile)
+    end
+
+    def self.from_lock(lockfile)
+      # gemfile_definition = from_gemfile(nil)
+      locked_definition = Locked.new(YAML.load_file(lockfile))
+      # raise GemfileError unless gemfile_definition.equivalent?(locked_definition)
+      locked_definition
+    end
+
+    attr_reader :dependencies, :sources
+
+    alias actual_dependencies dependencies
+
+    def initialize(dependencies, sources)
+      @dependencies = dependencies
+      @sources = sources
+    end
+
+    def local_index
+      @local_index ||= begin
+        index = Index.new
+
+        sources.each do |source|
+          next unless source.respond_to?(:local_specs)
+          index = source.local_specs.merge(index)
+        end
+
+        Index.from_installed_gems.merge(index)
+      end
+    end
+
+    # def equivalent?(other)
+    #   self.matches?(other) && other.matches?(self)
+    #   # other.matches?(self)
+    # end
+
+    # def matches?(other)
+    #   dependencies.all? do |dep|
+    #     dep =~ other.specs.find {|spec| spec.name == dep.name }
+    #   end
+    # end
+
+    class Locked < Definition
+      def initialize(details)
+        @details = details
+      end
+
+      def sources
+        @sources ||= @details["sources"].map do |args|
+          name, options = args.to_a.flatten
+          Bundler::Source.const_get(name).new(options)
+        end
+      end
+
+      def actual_dependencies
+        @actual_dependencies ||= @details["specs"].map do |args|
+          name, details = args.to_a.flatten
+          details["source"] = sources[details["source"]] if details.include?("source")
+          Bundler::Dependency.new(name, details.delete("version"), details)
+        end
+      end
+
+      def dependencies
+        @dependencies ||= @details["dependencies"].map do |args|
+          Bundler::Dependency.new(*args.to_a.flatten)
+        end
+      end
+    end
+  end
+end

data/lib/bundler/dependency.rb

@@ -1,62 +1,12 @@
-module Bundler
-  class InvalidEnvironmentName < StandardError; end
+require 'rubygems/dependency'
 
+module Bundler
   class Dependency < Gem::Dependency
-    attr_reader :name, :version, :require_as, :only, :except
-    attr_accessor :source
-
-    def initialize(name, options = {}, &block)
-      options.each do |k, v|
-        options[k.to_s] = v
-      end
-
-      super(name, options["version"] || ">= 0")
-
-      @require_as = options["require_as"]
-      @only       = options["only"]
-      @except     = options["except"]
-      @source     = options["source"]
-      @block      = block
-
-      if (@only && @only.include?("rubygems")) || (@except && @except.include?("rubygems"))
-        raise InvalidEnvironmentName, "'rubygems' is not a valid environment name"
-      end
-    end
-
-    def in?(environment)
-      environment = environment.to_s
-
-      return false unless !@only || @only.include?(environment)
-      return false if @except && @except.include?(environment)
-      true
-    end
-
-    def require_env(environment)
-      return unless in?(environment)
-
-      if @require_as
-        Array(@require_as).each { |file| require file }
-      else
-        begin
-          require name
-        rescue LoadError
-          # Do nothing
-        end
-      end
-
-      @block.call if @block
-    end
+    def initialize(name, version, options = {}, &blk)
+      super(name, version)
 
-    def no_bundle?
-      source == SystemGemSource.instance
+      @group  = options["group"] || :default
+      @source = options["source"]
     end
-
-    def ==(o)
-      [name, version, require_as, only, except] ==
-        [o.name, o.version, o.require_as, o.only, o.except]
-    end
-
-    alias version version_requirements
-
   end
-end
+end