bundler 1.0.0.beta.5 → 1.0.0.beta.8

data/TODO.md

@@ -1,16 +1,8 @@
 ## Bundler TODO list
 
-  - Check to make sure ~/.bundler/bin is in $PATH
   - Cache Git repositories
+  - Build options
+  - A gem shit list
   - 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/bin/bundle

@@ -13,8 +13,9 @@ begin
   Bundler::CLI.start
 rescue Bundler::BundlerError => e
   Bundler.ui.error e.message
+  Bundler.ui.error e.backtrace.join("\n") if ENV["BUNDLE_DEBUG"]
   exit e.status_code
 rescue Interrupt
   Bundler.ui.error "\nQuitting..."
   exit 1
-end
+end

data/lib/bundler/cli.rb

@@ -15,7 +15,7 @@ module Bundler
       Gem::DefaultUserInteraction.ui = UI::RGProxy.new(Bundler.ui)
     end
 
-    check_unknown_options! unless ARGV.include?("exec")
+    check_unknown_options! unless ARGV.include?("exec") || ARGV.include?("config")
 
     default_task :install
     class_option "no-color", :type => :boolean, :banner => "Disable colorization in output"
@@ -67,6 +67,7 @@ module Bundler
         Bundler.ui.warn "Install missing gems with `bundle install`"
         exit 1
       else
+        Bundler.load.lock
         Bundler.ui.info "The Gemfile's dependencies are satisfied"
       end
     end
@@ -96,7 +97,7 @@ module Bundler
       "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 => :boolean, :banner =>
+    method_option "binstubs", :type => :string, :lazy_default => "bin", :banner =>
       "Generate bin stubs for bundled gems to ./bin"
     def install(path = nil)
       opts = options.dup
@@ -106,13 +107,13 @@ 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[:bin] = 'bin' if opts[:binstubs]
+      Bundler.settings[:bin] = opts["binstubs"] if opts[:binstubs]
       Bundler.settings[:disable_shared_gems] = '1' if options["disable-shared-gems"] || path
       Bundler.settings.without = opts[:without]
       Bundler.ui.be_quiet! if opts[:quiet]
 
       Installer.install(Bundler.root, Bundler.definition, opts)
-      cache if Bundler.root.join("vendor/cache").exist?
+      Bundler.load.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
@@ -134,13 +135,13 @@ module Bundler
 
       if gems.empty? && sources.empty?
         # We're doing a full update
-        FileUtils.rm_f Bundler.root.join("Gemfile.lock")
+        Bundler.definition(true)
       else
         Bundler.definition(:gems => gems, :sources => sources)
       end
 
       Installer.install Bundler.root, Bundler.definition, "update" => true
-      cache if Bundler.root.join("vendor/cache").exist?
+      Bundler.load.cache if Bundler.root.join("vendor/cache").exist?
       Bundler.ui.confirm "Your bundle is updated! " +
         "Use `bundle show [gemname]` to see where a bundled gem is installed."
     end
@@ -161,6 +162,8 @@ module Bundler
       Calling show with [GEM] will list the exact location of that gem on your machine.
     D
     def show(gem_name = nil)
+      Bundler.load.lock
+
       if gem_name
         Bundler.ui.info locate_gem(gem_name)
       else
@@ -172,11 +175,13 @@ module Bundler
     end
     map %w(list) => "show"
 
-    desc "cache", "Cache all the gems to vendor/cache"
+    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."
     def cache
+      Bundler.definition.resolve_with_cache!
       Bundler.load.cache
-      Bundler.load.prune_cache unless options[:no_prune]
+      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."
@@ -194,7 +199,7 @@ module Bundler
     def package
       install
       # TODO: move cache contents here now that all bundles are locked
-      cache
+      Bundler.load.cache
     end
     map %w(pack) => :package
 
@@ -234,6 +239,48 @@ module Bundler
       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 you want to set the configuration for a specific
+      project, use the --local flag.
+
+      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(name, *values)
+      locations = Bundler.settings.locations(name)
+
+      if values.empty?
+        # TODO: Say something more useful here
+        locations.each do |location, value|
+          if value
+            Bundler.ui.info "#{location}: #{value}"
+          end
+        end
+      else
+        if local = locations[:local]
+          Bundler.ui.info "Your application has set #{name} to #{local.inspect}. This will override the " \
+            "system value you are currently setting"
+        end
+
+        if global = locations[:global]
+          Bundler.ui.info "You are replacing the current system value of #{name}, which is currently #{global}"
+        end
+
+        if env = locations[:env]
+          Bundler.ui.info "You have set a bundler environment variable for #{env}. This will take precedence " \
+            "over the system value you are setting"
+        end
+
+        Bundler.settings.set_global(name, values.join(" "))
+      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? }
@@ -297,14 +344,10 @@ module Bundler
     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
-
-    def self.printable_tasks
-      tasks = super.dup
-      nodoc = /^bundle (cache)/
-      tasks.reject!{|t| t.first =~ nodoc }
-      tasks
-    end
   end
 end

data/lib/bundler/definition.rb

@@ -34,22 +34,24 @@ module Bundler
       @dependencies, @sources, @unlock = dependencies, sources, unlock
       @remote = false
       @specs = nil
-      @unlock[:gems] ||= []
-      @unlock[:sources] ||= []
 
-      if lockfile && File.exists?(lockfile)
+      if lockfile && File.exists?(lockfile) && unlock != true
         locked = LockfileParser.new(File.read(lockfile))
         @platforms      = locked.platforms
         @locked_deps    = locked.dependencies
         @last_resolve   = SpecSet.new(locked.specs)
         @locked_sources = locked.sources
       else
+        @unlock         = {}
         @platforms      = []
         @locked_deps    = []
         @last_resolve   = SpecSet.new([])
         @locked_sources = []
       end
 
+      @unlock[:gems] ||= []
+      @unlock[:sources] ||= []
+
       current_platform = Gem.platforms.map { |p| p.to_generic }.compact.last
       @platforms |= [current_platform]
 
@@ -165,10 +167,13 @@ module Bundler
       out << "\n"
       out << "DEPENDENCIES\n"
 
+      handled = []
       dependencies.
         sort_by { |d| d.name }.
         each do |dep|
+          next if handled.include?(dep.name)
           out << dep.to_lock
+          handled << dep.name
       end
 
       out
@@ -183,7 +188,9 @@ module Bundler
     end
 
     def converge_sources
-      @sources = (@locked_sources & @sources) | @sources
+      @sources.map! do |source|
+        @locked_sources.find { |s| s == source } || source
+      end
       @sources.each do |source|
         source.unlock! if source.respond_to?(:unlock!) && @unlock[:sources].include?(source.name)
       end
@@ -192,9 +199,7 @@ module Bundler
     def converge_dependencies
       (@dependencies + @locked_deps).each do |dep|
         if dep.source
-          source = @sources.find { |s| dep.source == s }
-          raise "Something went wrong, there is no matching source" unless source
-          dep.source = source
+          dep.source = @sources.find { |s| dep.source == s }
         end
       end
     end

data/lib/bundler/dsl.rb

@@ -20,14 +20,16 @@ module Bundler
       @env             = nil
     end
 
-    def gemspec(opts)
+    def gemspec(opts = nil)
       path              = opts && opts[:path] || '.'
       name              = opts && opts[:name] || '*'
       development_group = opts && opts[:development_group] || :development
       gemspecs = Dir[File.join(path, "#{name}.gemspec")]
+
       case gemspecs.size
       when 1
         spec = Gem::Specification.load(gemspecs.first)
+        gem spec.name, :path => path
         spec.runtime_dependencies.each do |dep|
           gem dep.name, dep.requirement.to_s
         end
@@ -49,7 +51,7 @@ module Bundler
       end
 
       options = Hash === args.last ? args.pop : {}
-      version = args.last || ">= 0"
+      version = args || [">= 0"]
       if group = options[:groups] || options[:group]
         options[:group] = group
       end
@@ -57,6 +59,21 @@ module Bundler
       _deprecated_options(options)
       _normalize_options(name, version, options)
 
+      dep = Dependency.new(name, version, options)
+
+      if current = @dependencies.find { |d| d.name == dep.name }
+        if current.requirement != dep.requirement
+          raise DslError, "You cannot specify the same gem twice with different version requirements. " \
+                          "You specified: #{current.name} (#{current.requirement}) and " \
+                          "#{dep.name} (#{dep.requirement})"
+        end
+
+        if current.source != dep.source
+          raise DslError, "You cannot specify the same gem twice coming from different sources. You " \
+                          "specified that #{dep.name} (#{dep.requirement}) should come from " \
+                          "#{current.source || 'an unspecfied source'} and #{dep.source}"
+        end
+      end
       @dependencies << Dependency.new(name, version, options)
     end
 
@@ -200,7 +217,7 @@ module Bundler
       # Normalize git and path options
       ["git", "path"].each do |type|
         if param = opts[type]
-          options = _version?(version) ? opts.merge("name" => name, "version" => version) : opts.dup
+          options = _version?(version.first) ? opts.merge("name" => name, "version" => version.first) : opts.dup
           source = send(type, param, options, :prepend => true) {}
           opts["source"] = source
         end

data/lib/bundler/environment.rb

@@ -5,6 +5,9 @@ module Bundler
     def initialize(root, definition)
       @root = root
       @definition = definition
+
+      env_file = root.join('.bundle/environment.rb')
+      env_file.rmtree if env_file.exist?
     end
 
     def inspect
@@ -33,9 +36,6 @@ module Bundler
     end
 
     def lock
-      env_file = root.join('.bundle/environment.rb')
-      env_file.rmtree if env_file.exist?
-
       contents = @definition.to_lock
 
       File.open(root.join('Gemfile.lock'), 'w') do |f|

data/lib/bundler/lockfile_parser.rb

@@ -60,18 +60,19 @@ module Bundler
 
     def parse_dependency(line)
       if line =~ %r{^ {2}#{NAME_VERSION}(!)?$}
-        name, version, pinned = $1, $2, $3
+        name, version, pinned = $1, $2, $4
+        version = version.split(",").map { |d| d.strip } if version
 
         dep = Bundler::Dependency.new(name, version)
 
-        if pinned
+        if pinned && dep.name != 'bundler'
           dep.source = @specs.find { |s| s.name == dep.name }.source
 
           # Path sources need to know what the default name / version
           # to use in the case that there are no gemspecs present. A fake
           # gemspec is created based on the version set on the dependency
           # TODO: Use the version from the spec instead of from the dependency
-          if version =~ /^= (.+)$/ && dep.source.is_a?(Bundler::Source::Path)
+          if version && version.size == 1 && version.first =~ /^= (.+)$/ && dep.source.is_a?(Bundler::Source::Path)
             dep.source.name    = name
             dep.source.version = $1
           end
@@ -103,4 +104,4 @@ module Bundler
     end
 
   end
-end
+end

data/lib/bundler/rubygems_ext.rb

@@ -111,6 +111,11 @@ module Gem
     end
 
     def add_bundler_dependencies(*groups)
+      Bundler.ui.warn "#add_bundler_dependencies is deprecated and will " \
+        "be removed in Bundler 1.0. Instead, please use the #gemspec method " \
+        "in your Gemfile, which will pull in any dependencies specified in " \
+        "your gemspec"
+
       groups = [:default] if groups.empty?
       Bundler.definition.dependencies.each do |dep|
         if dep.groups.include?(:development)

data/lib/bundler/runtime.rb

@@ -4,11 +4,6 @@ module Bundler
   class Runtime < Environment
     include SharedHelpers
 
-    def initialize(*)
-      super
-      lock
-    end
-
     def setup(*groups)
       # Has to happen first
       clean_load_path
@@ -35,9 +30,19 @@ module Bundler
         load_paths = spec.load_paths.reject {|path| $LOAD_PATH.include?(path)}
         $LOAD_PATH.unshift(*load_paths)
       end
+
+      lock
+
       self
     end
 
+    REGEXPS = [
+      /^no such file to load -- (.+)$/i,
+      /^Missing \w+ (?:file\s*)?([^\s]+.rb)$/i,
+      /^Missing API definition file in (.+)$/i,
+      /^cannot load such file -- (.+)$/i,
+    ]
+
     def require(*groups)
       groups.map! { |g| g.to_sym }
       groups = [:default] if groups.empty?
@@ -47,17 +52,19 @@ module Bundler
         # groups
         next unless (dep.groups & groups).any?
 
+        required_file = nil
+
         begin
           # Loop through all the specified autorequires for the
           # dependency. If there are none, use the dependency's name
           # as the autorequire.
           Array(dep.autorequire || dep.name).each do |file|
+            required_file = file
             Kernel.require file
           end
-        rescue LoadError
-          # Only let a LoadError through if the autorequire was explicitly
-          # specified by the user.
-          raise if dep.autorequire
+        rescue LoadError => e
+          REGEXPS.find { |r| r =~ e.message }
+          raise if dep.autorequire || $1 != required_file
         end
       end
     end
@@ -80,18 +87,29 @@ module Bundler
         next if spec.name == 'bundler'
         spec.source.cache(spec) if spec.source.respond_to?(:cache)
       end
+      prune_cache unless Bundler.settings[:no_prune]
     end
 
     def prune_cache
       FileUtils.mkdir_p(cache_path)
 
-      Bundler.ui.info "Removing outdated .gem files from vendor/cache"
-      Pathname.glob(cache_path.join("*.gem").to_s).each do |gem_path|
-        cached_spec = Gem::Format.from_file_by_path(gem_path).spec
-        next unless Gem::Platform.match(cached_spec.platform)
-        unless specs.any?{|s| s.full_name == cached_spec.full_name }
-          Bundler.ui.info "  * #{File.basename(gem_path)}"
-          gem_path.rmtree
+      resolve = @definition.resolve
+      cached  = Dir["#{cache_path}/*.gem"]
+
+      cached = cached.delete_if do |path|
+        spec = Gem::Format.from_file_by_path(path).spec
+
+        resolve.any? do |s|
+          s.name == spec.name && s.version == spec.version
+        end
+      end
+
+      if cached.any?
+        Bundler.ui.info "Removing outdated .gem files from vendor/cache"
+
+        cached.each do |path|
+          Bundler.ui.info "  * #{File.basename(path)}"
+          File.delete(path)
         end
       end
     end