bundler 1.0.3 → 1.0.5

data/lib/bundler/dsl.rb

@@ -2,10 +2,10 @@ require 'bundler/dependency'
 
 module Bundler
   class Dsl
-    def self.evaluate(gemfile)
+    def self.evaluate(gemfile, lockfile, unlock)
       builder = new
       builder.instance_eval(Bundler.read_file(gemfile.to_s), gemfile.to_s, 1)
-      builder.to_definition
+      builder.to_definition(lockfile, unlock)
     end
 
     VALID_PLATFORMS = Bundler::Dependency::PLATFORM_MAP.keys.freeze
@@ -30,6 +30,7 @@ module Bundler
       case gemspecs.size
       when 1
         spec = Gem::Specification.load(gemspecs.first)
+        raise InvalidOption, "There was an error loading the gemspec at #{gemspecs.first}." unless spec
         gem spec.name, :path => path
         spec.runtime_dependencies.each do |dep|
           gem dep.name, *dep.requirement.as_list

data/lib/bundler/gem_helper.rb

@@ -1,19 +1,18 @@
 $:.unshift File.expand_path('../vendor', __FILE__)
-require 'open3'
 require 'thor'
 require 'bundler'
 
 module Bundler
   class GemHelper
     def self.install_tasks(opts = nil)
-      dir = caller.find{|c| /Rakefile:/}[/^(.*?)\/Rakefile:/, 1]
+      dir = File.dirname(Rake.application.rakefile_location)
       self.new(dir, opts && opts[:name]).install
     end
 
     attr_reader :spec_path, :base, :gemspec
 
     def initialize(base, name = nil)
-      Bundler.ui = UI::Shell.new(Thor::Shell::Color.new)
+      Bundler.ui = UI::Shell.new(Thor::Base.shell.new)
       @base = base
       gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "*.gemspec")]
       raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
@@ -40,8 +39,8 @@ module Bundler
 
     def build_gem
       file_name = nil
-      sh("gem build #{spec_path}") { |out, err|
-        raise err if !out[/Successfully/]
+      sh("gem build #{spec_path}") { |out, code|
+        raise out unless out[/Successfully/]
         file_name = File.basename(built_gem_path)
         FileUtils.mkdir_p(File.join(base, 'pkg'))
         FileUtils.mv(built_gem_path, 'pkg')
@@ -52,8 +51,8 @@ module Bundler
 
     def install_gem
       built_gem_path = build_gem
-      out, err, code = sh_with_code("gem install #{built_gem_path}")
-      raise err if err[/ERROR/]
+      out, code = sh_with_code("gem install #{built_gem_path}")
+      raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output" unless out[/Successfully installed/]
       Bundler.ui.confirm "#{name} (#{version}) installed"
     end
 
@@ -69,7 +68,8 @@ module Bundler
 
     protected
     def rubygem_push(path)
-      sh("gem push #{path}")
+      out, status = sh("gem push #{path}")
+      raise "Gem push failed due to lack of RubyGems.org credentials." if out[/Enter your RubyGems.org credentials/]
       Bundler.ui.confirm "Pushed #{name} #{version} to rubygems.org"
     end
 
@@ -84,8 +84,9 @@ module Bundler
     end
 
     def perform_git_push(options = '')
-      out, err, code = sh_with_code "git push --quiet#{options}"
-      raise err unless err == ''
+      cmd = "git push #{options}"
+      out, code = sh_with_code(cmd)
+      raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n" unless code == 0
     end
 
     def guard_already_tagged
@@ -99,23 +100,20 @@ module Bundler
     end
 
     def clean?
-      sh("git ls-files -dm").split("\n").size.zero?
+      out, code = sh_with_code("git diff --exit-code")
+      code == 0
     end
 
     def tag_version
-      sh "git tag -am 'Version #{version}' #{version_tag}"
-      Bundler.ui.confirm "Tagged #{tagged_sha} with #{version_tag}"
+      sh "git tag -a -m \"Version #{version}\" #{version_tag}"
+      Bundler.ui.confirm "Tagged #{version_tag}"
       yield if block_given?
     rescue
-      Bundler.ui.error "Untagged #{tagged_sha} with #{version_tag} due to error"
-      sh "git tag -d #{version_tag}"
+      Bundler.ui.error "Untagged #{version_tag} due to error"
+      sh_with_code "git tag -d #{version_tag}"
       raise
     end
 
-    def tagged_sha
-      sh("git show-ref --tags #{version_tag}").split(' ').first[0, 8]
-    end
-
     def version
       gemspec.version
     end
@@ -129,20 +127,21 @@ module Bundler
     end
 
     def sh(cmd, &block)
-      out, err, code = sh_with_code(cmd, &block)
-      code == 0 ? out : raise(out.empty? ? err : out)
+      out, code = sh_with_code(cmd, &block)
+      code == 0 ? out : raise(out.empty? ? "Running `#{cmd}' failed. Run this command directly for more detailed output." : out)
     end
 
     def sh_with_code(cmd, &block)
-      outbuf, errbuf = '', ''
+      cmd << " 2>&1"
+      outbuf = ''
+      Bundler.ui.debug(cmd)
       Dir.chdir(base) {
-        stdin, stdout, stderr = *Open3.popen3(cmd)
+        outbuf = `#{cmd}`
         if $? == 0
-          outbuf, errbuf = stdout.read, stderr.read
-          block.call(outbuf, errbuf) if block
+          block.call(outbuf) if block
         end
       }
-      [outbuf, errbuf, $?]
+      [outbuf, $?]
     end
   end
 end

data/lib/bundler/installer.rb

@@ -53,6 +53,7 @@ module Bundler
           old_args = Gem::Command.build_args
           Gem::Command.build_args = [Bundler.settings["build.#{spec.name}"]]
           spec.source.install(spec)
+          Bundler.ui.debug "from #{spec.loaded_from} "
         ensure
           Gem::Command.build_args = old_args
         end

data/lib/bundler/resolver.rb

@@ -21,10 +21,7 @@ end
 
 module Bundler
   class Resolver
-    ALL = [ Gem::Platform::RUBY,
-            Gem::Platform::JAVA,
-            Gem::Platform::MSWIN,
-            Gem::Platform::MING]
+    ALL = Bundler::Dependency::PLATFORM_MAP.values.uniq.freeze
 
     class SpecGroup < Array
       include GemHelpers
@@ -124,9 +121,9 @@ module Bundler
     # ==== Returns
     # <GemBundle>,nil:: If the list of dependencies can be resolved, a
     #   collection of gemspecs is returned. Otherwise, nil is returned.
-    def self.resolve(requirements, index, source_requirements = {}, base = [])
+    def self.resolve(requirements, index, source_requirements = {}, base = [], sort = true)
       base = SpecSet.new(base) unless base.is_a?(SpecSet)
-      resolver = new(index, source_requirements, base)
+      resolver = new(index, source_requirements, base, sort)
       result = catch(:success) do
         resolver.start(requirements)
         raise resolver.version_conflict
@@ -135,13 +132,14 @@ module Bundler
       SpecSet.new(result)
     end
 
-    def initialize(index, source_requirements, base)
+    def initialize(index, source_requirements, base, sort)
       @errors               = {}
       @stack                = []
       @base                 = base
       @index                = index
       @missing_gems         = Hash.new(0)
       @source_requirements  = source_requirements
+      @sort                 = sort
     end
 
     def debug
@@ -174,12 +172,14 @@ module Bundler
       #   1) Is this gem already activated?
       #   2) Do the version requirements include prereleased gems?
       #   3) Sort by number of gems available in the source.
+      # This is a pretty expensive operation, so we skip it when the bundle is
+      # locked and sorting isn't necessary.
       reqs = reqs.sort_by do |a|
         [ activated[a.name] ? 0 : 1,
           a.requirement.prerelease? ? 0 : 1,
           @errors[a.name]   ? 0 : 1,
           activated[a.name] ? 0 : search(a).size ]
-      end
+      end if @sort
 
       debug { "Activated:\n" + activated.values.map { |a| "  #{a.name} (#{a.version})" }.join("\n") }
       debug { "Requirements:\n" + reqs.map { |r| "  #{r.name} (#{r.requirement})"}.join("\n") }
@@ -198,8 +198,9 @@ module Bundler
         # Force the current
         if current.name == 'bundler' && !existing
           existing = search(DepProxy.new(Gem::Dependency.new('bundler', VERSION), Gem::Platform::RUBY)).first
-          activated['bundler'] = existing
           raise GemNotFound, %Q{Bundler could not find gem "bundler" (#{VERSION})} unless existing
+          existing.required_by << existing
+          activated['bundler'] = existing
         end
 
         if current.requirement.satisfied_by?(existing.version)
@@ -230,9 +231,10 @@ module Bundler
           parent ||= existing.required_by.last if existing.respond_to?(:required_by)
           # We track the spot where the current gem was activated because we need
           # to keep a list of every spot a failure happened.
-          debug { "    -> Jumping to: #{parent.name}" }
-          if parent
-            throw parent.name, existing.respond_to?(:required_by) && existing.required_by.last.name
+          if parent && parent.name != 'bundler'
+            debug { "    -> Jumping to: #{parent.name}" }
+            required_by = existing.respond_to?(:required_by) && existing.required_by.last
+            throw parent.name, required_by && required_by.name
           else
             # The original set of dependencies conflict with the base set of specs
             # passed to the resolver. This is by definition an impossible resolve.
@@ -272,7 +274,7 @@ module Bundler
             else
               message = "Could not find gem '#{current}' "
               if @index.sources.include?(Bundler::Source::Rubygems)
-                message << "in any of the gem sources."
+                message << "in any of the gem sources listed in your Gemfile."
               else
                 message << "in the gems available on this machine."
               end
@@ -413,13 +415,23 @@ module Bundler
 
           o << gem_message(requirement)
 
+          # If the origin is "bundler", the conflict is us
+          if origin.name == "bundler"
+            o << "  Current Bundler version:\n"
+            newer_bundler_required = requirement.requirement > Gem::Requirement.new(origin.version)
           # If the origin is a LockfileParser, it does not respond_to :required_by
-          unless origin.respond_to?(:required_by) && required_by = origin.required_by.first
+          elsif !origin.respond_to?(:required_by) || !(required_by = origin.required_by.first)
             o << "  In snapshot (Gemfile.lock):\n"
           end
 
           o << gem_message(origin)
 
+          # If the bundle wants a newer bundler than the running bundler, explain
+          if origin.name == "bundler" && newer_bundler_required
+            o << "Your version of Bundler is older than the one requested by the Gemfile.\n"
+            o << "Perhaps you need to update Bundler by running `gem install bundler`."
+          end
+
         # origin is nil if the required gem and version cannot be found in any of
         # the specified sources
         else
@@ -449,6 +461,7 @@ module Bundler
           end
 
         end
+        o
       end
     end
   end

data/lib/bundler/rubygems_ext.rb

@@ -121,7 +121,7 @@ module Gem
   class Platform
     JAVA  = Gem::Platform.new('java')
     MSWIN = Gem::Platform.new('mswin32')
-    MING  = Gem::Platform.new('x86-mingw32')
+    MINGW = Gem::Platform.new('x86-mingw32')
 
     def hash
       @cpu.hash ^ @os.hash ^ @version.hash
@@ -172,16 +172,19 @@ module Bundler
     GENERICS = [
       Gem::Platform::JAVA,
       Gem::Platform::MSWIN,
-      Gem::Platform::MING,
+      Gem::Platform::MINGW,
       Gem::Platform::RUBY
     ]
 
     def generic(p)
-      if p == Gem::Platform::RUBY
-        return p
-      end
+      return p if p == Gem::Platform::RUBY
 
-      GENERIC_CACHE[p] ||= GENERICS.find { |p2| p =~ p2 } || Gem::Platform::RUBY
+      GENERIC_CACHE[p] ||= begin
+        found = GENERICS.find do |p2|
+          p2.is_a?(Gem::Platform) && p.os == p2.os
+        end
+        found || Gem::Platform::RUBY
+      end
     end
   end
 

data/lib/bundler/runtime.rb

@@ -101,7 +101,7 @@ module Bundler
         spec = Gem::Format.from_file_by_path(path).spec
 
         resolve.any? do |s|
-          s.name == spec.name && s.version == spec.version
+          s.name == spec.name && s.version == spec.version && !s.source.is_a?(Bundler::Source::Git)
         end
       end
 

data/lib/bundler/setup.rb

@@ -6,6 +6,7 @@ if Bundler::SharedHelpers.in_bundle?
     Bundler.setup
   rescue Bundler::BundlerError => e
     puts "\e[31m#{e.message}\e[0m"
+    puts e.backtrace.join("\n") if ENV["DEBUG"]
     exit e.status_code
   end
 

data/lib/bundler/shared_helpers.rb

@@ -18,7 +18,7 @@ module Bundler
 
     def default_gemfile
       gemfile = find_gemfile
-      gemfile or raise GemfileNotFound, "Could not locate Gemfile"
+      raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
       Pathname.new(gemfile)
     end
 
@@ -33,12 +33,19 @@ module Bundler
   private
 
     def find_gemfile
-      return ENV['BUNDLE_GEMFILE'] if ENV['BUNDLE_GEMFILE']
+      given = ENV['BUNDLE_GEMFILE']
+      return given if given && !given.empty?
 
       previous = nil
       current  = File.expand_path(Dir.pwd)
 
       until !File.directory?(current) || current == previous
+        if ENV['BUNDLE_SPEC_RUN']
+          # avoid stepping above the tmp directory when testing
+          return nil if File.file?(File.join(current, 'bundler.gemspec'))
+        end
+
+        # otherwise return the Gemfile if it's there
         filename = File.join(current, 'Gemfile')
         return filename if File.file?(filename)
         current, previous = File.expand_path("..", current), current
@@ -50,9 +57,9 @@ module Bundler
       if defined?(::Gem)
         me = File.expand_path("../../", __FILE__)
         $LOAD_PATH.reject! do |p|
-          next if File.expand_path(p).include?(me)
+          next if File.expand_path(p) =~ /^#{me}/
           p != File.dirname(__FILE__) &&
-            Gem.path.any? { |gp| p.include?(gp) }
+            Gem.path.any?{|gp| p =~ /^#{gp}/ }
         end
         $LOAD_PATH.uniq!
       end

data/lib/bundler/source.rb

@@ -39,12 +39,6 @@ module Bundler
 
       alias == eql?
 
-      # Not really needed, but it seems good to implement this method for interface
-      # consistency. Source name is mostly used to identify Path & Git sources
-      def name
-        ":gems"
-      end
-
       def options
         { "remotes" => @remotes.map { |r| r.to_s } }
       end
@@ -62,9 +56,10 @@ module Bundler
       end
 
       def to_s
-        remotes = self.remotes.map { |r| r.to_s }.join(', ')
-        "rubygems repository #{remotes}"
+        remote_names = self.remotes.map { |r| r.to_s }.join(', ')
+        "rubygems repository #{remote_names}"
       end
+      alias_method :name, :to_s
 
       def specs
         @specs ||= fetch_specs
@@ -193,8 +188,18 @@ module Bundler
           idx = Index.new
           @caches.each do |path|
             Dir["#{path}/*.gem"].each do |gemfile|
-              next if name == 'bundler'
-              s = Gem::Format.from_file_by_path(gemfile).spec
+              next if gemfile =~ /bundler\-[\d\.]+?\.gem/
+
+              # Try to skip decompressing the gem to get at the gemspec if possible
+              cached_gemspec = gemfile.gsub(%r{cache/(.*?)\.gem}, 'specifications/\1.gemspec')
+              s = Gem::Specification.load(cached_gemspec) if File.exist?(cached_gemspec)
+
+              begin
+                s ||= Gem::Format.from_file_by_path(gemfile).spec
+              rescue Gem::Package::FormatError
+                raise GemspecError, "Could not read gem at #{gemfile}. It may be corrupted."
+              end
+
               s.source = self
               idx << s
             end
@@ -313,7 +318,7 @@ module Bundler
 
       def eql?(o)
         o.instance_of?(Path) &&
-        path == o.path &&
+        path.expand_path(Bundler.root) == o.path.expand_path(Bundler.root) &&
         name == o.name &&
         version == o.version
       end
@@ -327,7 +332,7 @@ module Bundler
       def load_spec_files
         index = Index.new
 
-        expanded_path = path.expand_path
+        expanded_path = path.expand_path(Bundler.root)
 
         if File.directory?(expanded_path)
           Dir["#{expanded_path}/#{@glob}"].each do |file|
@@ -403,7 +408,7 @@ module Bundler
       alias specs local_specs
 
       def cache(spec)
-        unless path.to_s.index(Bundler.root.to_s) == 0
+        unless path.expand_path(Bundler.root).to_s.index(Bundler.root.to_s) == 0
           Bundler.ui.warn "  * #{spec.name} at `#{path}` will not be cached."
         end
       end
@@ -460,6 +465,10 @@ module Bundler
 
       def initialize(options)
         super
+
+        # stringify options that could be set as symbols
+        %w(ref branch tag revision).each{|k| options[k] = options[k].to_s if options[k] }
+
         @uri        = options["uri"]
         @ref        = options["ref"] || options["branch"] || options["tag"] || 'master'
         @revision   = options["revision"]
@@ -494,8 +503,8 @@ module Bundler
       alias == eql?
 
       def to_s
-        ref = @options["ref"] ? shortref_for_display(@options["ref"]) : @ref
-        "#{@uri} (at #{ref})"
+        sref = options["ref"] ? shortref_for_display(options["ref"]) : ref
+        "#{uri} (at #{sref})"
       end
 
       def name