bundler 1.1.pre.8 → 1.1.pre.9

data/lib/bundler/definition.rb

@@ -197,6 +197,10 @@ module Bundler
     def lock(file)
       contents = to_lock
 
+      # Convert to \r\n if the existing lock has them
+      # i.e., Windows with `git config core.autocrlf=true`
+      contents.gsub!(/\n/, "\r\n") if @lockfile_contents.match("\r\n")
+
       return if @lockfile_contents == contents
 
       if Bundler.settings[:frozen]
@@ -204,10 +208,6 @@ module Bundler
         return
       end
 
-      # Convert to \r\n if the existing lock has them
-      # i.e., Windows with `git config core.autocrlf=true`
-      contents.gsub!(/\n/, "\r\n") if @lockfile_contents.match("\r\n")
-
       File.open(file, 'wb'){|f| f.puts(contents) }
     end
 

data/lib/bundler/dependency.rb

@@ -71,15 +71,8 @@ module Bundler
     end
 
     def to_lock
-      out = "  #{name}"
-
-      unless requirement == Gem::Requirement.default
-        reqs = requirement.requirements.map{|o,v| "#{o} #{v}" }
-        out << " (#{reqs.join(', ')})"
-      end
-
+      out = super
       out << '!' if source
-
       out << "\n"
     end
 

data/lib/bundler/deployment.rb

@@ -4,9 +4,11 @@ module Bundler
       if defined?(Capistrano) && context.is_a?(Capistrano::Configuration)
         context_name = "capistrano"
         role_default = "{:except => {:no_release => true}}"
+        error_type = ::Capistrano::CommandError
       else
         context_name = "vlad"
         role_default = "[:app]"
+        error_type = ::Rake::CommandFailedError
       end
 
       roles = context.fetch(:bundle_roles, false)
@@ -39,13 +41,16 @@ module Bundler
           bundle_dir     = context.fetch(:bundle_dir, File.join(context.fetch(:shared_path), 'bundle'))
           bundle_gemfile = context.fetch(:bundle_gemfile, "Gemfile")
           bundle_without = [*context.fetch(:bundle_without, [:development, :test])].compact
-
-          args = ["--gemfile #{File.join(context.fetch(:current_release), bundle_gemfile)}"]
+          current_release = context.fetch(:current_release)
+          if current_release.to_s.empty?
+            raise error_type.new("Cannot detect current release path - make sure you have deployed at least once.")
+          end
+          args = ["--gemfile #{File.join(current_release, bundle_gemfile)}"]
           args << "--path #{bundle_dir}" unless bundle_dir.to_s.empty?
           args << bundle_flags.to_s
           args << "--without #{bundle_without.join(" ")}" unless bundle_without.empty?
 
-          run "cd #{context.fetch(:current_release)} && #{bundle_cmd} install #{args.join(' ')}"
+          run "cd #{current_release} && #{bundle_cmd} install #{args.join(' ')}"
         end
       end
     end

data/lib/bundler/dsl.rb

@@ -20,6 +20,8 @@ module Bundler
       @env             = nil
     end
 
+    attr_accessor :dependencies
+
     def gemspec(opts = nil)
       path              = opts && opts[:path] || '.'
       name              = opts && opts[:name] || '{,*}'
@@ -167,14 +169,6 @@ module Bundler
       end
     end
 
-    deprecate :only, :group
-    deprecate :except
-    deprecate :disable_system_gems
-    deprecate :disable_rubygems
-    deprecate :clear_sources
-    deprecate :bundle_path
-    deprecate :bin_path
-
   private
 
     def _normalize_hash(opts)
@@ -217,7 +211,7 @@ module Bundler
         raise DslError, "`#{p}` is not a valid platform. The available options are: #{VALID_PLATFORMS.inspect}"
       end
 
-      if github = opts.delete(:github)
+      if github = opts.delete("github")
         github = "#{github}/#{github}" unless github.include?("/")
         opts["git"] = "git://github.com/#{github}.git"
       end
@@ -241,15 +235,6 @@ module Bundler
     end
 
     def _deprecated_options(options)
-      if options.include?(:require_as)
-        raise DeprecatedError, "Please replace :require_as with :require"
-      elsif options.include?(:vendored_at)
-        raise DeprecatedError, "Please replace :vendored_at with :path"
-      elsif options.include?(:only)
-        raise DeprecatedError, "Please replace :only with :group"
-      elsif options.include?(:except)
-        raise DeprecatedError, "The :except option is no longer supported"
-      end
     end
   end
 end

data/lib/bundler/fetcher.rb

@@ -117,7 +117,7 @@ module Bundler
       begin
         Bundler.ui.debug "Fetching from: #{uri}"
         response = @@connection.request(uri)
-      rescue SocketError, Timeout
+      rescue SocketError, Timeout, Net::HTTP::Persistent::Error
         raise Bundler::HTTPError, "Network error while fetching #{uri}"
       end
 
@@ -147,8 +147,20 @@ module Bundler
 
       spec_list = gem_list.map do |s|
         dependencies = s[:dependencies].map do |d|
-          name, requirement = d
-          dep = Gem::Dependency.new(name, requirement.split(", "))
+          begin
+            name, requirement = d
+            dep = Gem::Dependency.new(name, requirement.split(", "))
+          rescue ArgumentError => e
+            if e.message.include?('Illformed requirement ["#<YAML::Syck::DefaultKey')
+              puts # we shouldn't print the error message on the "fetching info" status line
+              raise GemspecError, %{Unfortunately, the gem #{s[:name]} (#{s[:number]}) } +
+                %{has an invalid gemspec. As a result, Bundler cannot install this Gemfile. } +
+                %{Please ask the gem author to yank the bad version to fix this issue. For } +
+                %{more information, see http://bit.ly/illformed-requirement.}
+            else
+              raise e
+            end
+          end
 
           deps_list << dep.name
 

data/lib/bundler/gem_helper.rb

@@ -41,7 +41,7 @@ module Bundler
 
     def build_gem
       file_name = nil
-      sh("gem build '#{spec_path}'") { |out, code|
+      sh("gem build -V '#{spec_path}'") { |out, code|
         file_name = File.basename(built_gem_path)
         FileUtils.mkdir_p(File.join(base, 'pkg'))
         FileUtils.mv(built_gem_path, 'pkg')

data/lib/bundler/gem_installer.rb

@@ -0,0 +1,9 @@
+require 'rubygems/installer'
+
+module Bundler
+  class GemInstaller < Gem::Installer
+    def check_executable_overwrite(filename)
+      # Bundler needs to install gems regardless of binstub overwriting
+    end
+  end
+end

data/lib/bundler/installer.rb

@@ -53,21 +53,7 @@ module Bundler
       # the gem.
       Installer.post_install_messages = {}
       specs.each do |spec|
-        Bundler::Fetcher.fetch(spec) if spec.source.is_a?(Bundler::Source::Rubygems)
-
-        # unless requested_specs.include?(spec)
-        #   Bundler.ui.debug "  * Not in requested group; skipping."
-        #   next
-        # end
-
-        Bundler.rubygems.with_build_args [Bundler.settings["build.#{spec.name}"]] do
-          spec.source.install(spec)
-          Bundler.ui.debug "from #{spec.loaded_from} "
-        end
-
-        Bundler.ui.info ""
-        generate_bundler_executable_stubs(spec) if Bundler.settings[:bin]
-        FileUtils.rm_rf(Bundler.tmp)
+        install_gem_from_spec(spec)
       end
 
       lock
@@ -76,6 +62,35 @@ module Bundler
 
   private
 
+    def install_gem_from_spec(spec)
+      # Download the gem to get the spec, because some specs that are returned
+      # by rubygems.org are broken and wrong.
+      Bundler::Fetcher.fetch(spec) if spec.source.is_a?(Bundler::Source::Rubygems)
+
+      # Fetch the build settings, if there are any
+      settings = Bundler.settings["build.#{spec.name}"]
+      Bundler.rubygems.with_build_args [settings] do
+        spec.source.install(spec)
+        Bundler.ui.debug "from #{spec.loaded_from} "
+      end
+
+      # newline comes after installing, some gems say "with native extensions"
+      Bundler.ui.info ""
+      generate_bundler_executable_stubs(spec) if Bundler.settings[:bin]
+      FileUtils.rm_rf(Bundler.tmp)
+    rescue Exception => e
+      # install hook failed
+      raise e if e.is_a?(Gem::InstallError)
+
+      # other failure, likely a native extension build failure
+      Bundler.ui.info ""
+      Bundler.ui.warn "#{e.class}: #{e.message}"
+      msg = "An error occured while installing #{spec.name} (#{spec.version}),"
+      msg << " and Bundler cannot continue.\nMake sure that `gem install"
+      msg << " #{spec.name} -v '#{spec.version}'` succeeds before bundling."
+      raise Bundler::InstallError, msg
+    end
+
     def generate_bundler_executable_stubs(spec)
       bin_path = Bundler.bin_path
       template = File.read(File.expand_path('../templates/Executable', __FILE__))
@@ -91,8 +106,8 @@ module Bundler
     end
 
     def generate_standalone(groups)
-      path = Bundler.settings[:path]
-      bundler_path = File.join(path, "bundler")
+      standalone_path = Bundler.settings[:path]
+      bundler_path = File.join(standalone_path, "bundler")
       FileUtils.mkdir_p(bundler_path)
 
       paths = []
@@ -108,7 +123,7 @@ module Bundler
 
         spec.require_paths.each do |path|
           full_path = File.join(spec.full_gem_path, path)
-          paths << Pathname.new(full_path).relative_path_from(Bundler.root.join("bundle/bundler"))
+          paths << Pathname.new(full_path).relative_path_from(Bundler.root.join(bundler_path))
         end
       end
 

data/lib/bundler/resolver.rb

@@ -334,8 +334,13 @@ module Bundler
       length = @stack.length
       @stack << requirement.name
       retval = catch(requirement.name) do
+        # clear the search cache since the catch means we couldn't meet the
+        # requirement we need with the current constraints on search
+        clear_search_cache
+        # try to resolve the next option
         resolve(reqs, activated)
       end
+
       # Since we're doing a lot of throw / catches. A push does not necessarily match
       # up to a pop. So, we simply slice the stack back to what it was before the catch
       # block.
@@ -347,15 +352,21 @@ module Bundler
       search(dep).size
     end
 
-    def search(dep)
-      return @deps_for[dep.to_s] if @deps_for[dep.to_s]
+    def clear_search_cache
+      @deps_for = {}
+    end
 
+    def search(dep)
       if base = @base[dep.name] and base.any?
         reqs = [dep.requirement.as_list, base.first.version.to_s].flatten.compact
         d = Gem::Dependency.new(base.first.name, *reqs)
       else
         d = dep.dep
       end
+
+      key = "#{d}-#{dep.__platform}"
+      return @deps_for[key] if @deps_for[key]
+
       index = @source_requirements[d.name] || @index
       results = index.search(d, @base[d.name])
 
@@ -373,7 +384,8 @@ module Bundler
       else
         deps = []
       end
-      @deps_for[dep.to_s] = deps
+
+      @deps_for[key] = deps
     end
 
     def clean_req(req)
@@ -417,7 +429,7 @@ module Bundler
           # 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)
+            other_bundler_required = !requirement.requirement.satisfied_by?(origin.version)
           # If the origin is a LockfileParser, it does not respond_to :required_by
           elsif !origin.respond_to?(:required_by) || !(origin.required_by.first)
             o << "  In snapshot (Gemfile.lock):\n"
@@ -426,9 +438,9 @@ module Bundler
           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`."
+          if origin.name == "bundler" && other_bundler_required
+            o << "This Gemfile requires a different version of Bundler.\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

data/lib/bundler/rubygems_ext.rb

@@ -40,6 +40,7 @@ module Gem
     end
 
     # RubyGems 1.8+ used only.
+    remove_method :gem_dir if method_defined? :gem_dir
     def gem_dir
       full_gem_path
     end
@@ -107,7 +108,7 @@ module Gem
     def to_lock
       out = "  #{name}"
       unless requirement == Gem::Requirement.default
-        reqs = requirement.requirements.map{|o,v| "#{o} #{v}" }
+        reqs = requirement.requirements.map{|o,v| "#{o} #{v}" }.sort.reverse
         out << " (#{reqs.join(', ')})"
       end
       out
@@ -135,6 +136,7 @@ module Gem
     MSWIN = Gem::Platform.new('mswin32')
     MINGW = Gem::Platform.new('x86-mingw32')
 
+    undef_method :hash if method_defined? :hash
     def hash
       @cpu.hash ^ @os.hash ^ @version.hash
     end

data/lib/bundler/rubygems_integration.rb

@@ -50,7 +50,12 @@ module Bundler
     end
 
     def gem_bindir
-      Gem.bindir
+      # We use Gem.dir/bin because on OS X, Gem.bindir is hardcoded to return
+      # /usr/bin, a directory owned by root. Users who chown Gem.dir need bins
+      # to be installed where they have permissions. Furthermore, the official
+      # solution to change the bindir is adding -n to .gemrc, but Rubygems does
+      # not honor the -n option in either Gem.bindir or Installer.new.bindir.
+      File.join Gem.dir, "bin"
     end
 
     def user_home
@@ -180,6 +185,7 @@ module Bundler
     end
 
     def stub_source_index170(specs)
+      Gem::SourceIndex.send(:alias_method, :old_initialize, :initialize)
       Gem::SourceIndex.send(:define_method, :initialize) do |*args|
         @gems = {}
         # You're looking at this thinking: Oh! This is how I make those
@@ -205,7 +211,7 @@ module Bundler
       gem_class = (class << Gem ; self ; end)
       gem_class.send(:remove_method, :bin_path)
       gem_class.send(:define_method, :bin_path) do |name, *args|
-        exec_name, *reqs = args
+        exec_name = args.first
 
         if exec_name == 'bundle'
           return ENV['BUNDLE_BIN_PATH']
@@ -254,9 +260,14 @@ module Bundler
     # by monkeypatching it into the method in Rubygems 1.3.6 and 1.3.7.
     def backport_segment_generation
       Gem::Version.send(:define_method, :segments) do
-        @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
-          /^\d+$/ =~ s ? s.to_i : s
+        @segments_generated ||= false
+        unless @segments_generated
+          @segments ||= @version.scan(/[0-9a-z]+/i).map do |s|
+            /^\d+$/ =~ s ? s.to_i : s
+          end
         end
+        @segments_generated = true
+        @segments
       end
     end
 
@@ -268,11 +279,33 @@ module Bundler
       end
     end
 
+    def backport_cache_file
+      Gem::Specification.send(:define_method, :cache_dir) do
+        @cache_dir ||= File.join base_dir, "cache"
+      end
+
+      Gem::Specification.send(:define_method, :cache_file) do
+        @cache_file ||= File.join cache_dir, "#{full_name}.gem"
+      end
+    end
+
+    def backport_spec_file
+      Gem::Specification.send(:define_method, :spec_dir) do
+        @spec_dir ||= File.join base_dir, "specifications"
+      end
+
+      Gem::Specification.send(:define_method, :spec_file) do
+        @spec_file ||= File.join spec_dir, "#{full_name}.gemspec"
+      end
+    end
+
     # Rubygems 1.4 through 1.6
     class Legacy < RubygemsIntegration
       def initialize
         super
         backport_base_dir
+        backport_cache_file
+        backport_spec_file
       end
 
       def stub_rubygems(specs)

data/lib/bundler/runtime.rb

@@ -69,7 +69,18 @@ module Bundler
           end
         rescue LoadError => e
           REGEXPS.find { |r| r =~ e.message }
-          raise if dep.autorequire || $1 != required_file
+
+          if dep.name.include?('-')
+            begin
+              namespaced_file = dep.name.gsub('-', '/')
+              Kernel.require namespaced_file
+            rescue LoadError
+              REGEXPS.find { |r| r =~ e.message }
+              raise if dep.autorequire || $1.gsub('-', '/') != namespaced_file
+            end
+          else
+            raise if dep.autorequire || $1 != required_file
+          end
         end
       end
     end
@@ -120,30 +131,45 @@ module Bundler
     end
 
     def clean
-      return false if Bundler.settings[:path] == nil
-
       gem_bins             = Dir["#{Gem.dir}/bin/*"]
       git_dirs             = Dir["#{Gem.dir}/bundler/gems/*"]
+      git_cache_dirs       = Dir["#{Gem.dir}/cache/bundler/git/*"]
       gem_dirs             = Dir["#{Gem.dir}/gems/*"]
-      spec_gem_paths       = specs.collect {|spec| spec.full_gem_path }
-      spec_gem_executables = specs.collect do |spec|
-        spec.executables.collect do |executable|
+      gem_files            = Dir["#{Gem.dir}/cache/*.gem"]
+      gemspec_files        = Dir["#{Gem.dir}/specifications/*.gemspec"]
+      spec_gem_paths       = []
+      spec_git_paths       = []
+      spec_git_cache_dirs  = []
+      spec_gem_executables = []
+      spec_cache_paths     = []
+      spec_gemspec_paths   = []
+      specs.each do |spec|
+        spec_gem_paths << spec.full_gem_path
+        # need to check here in case gems are nested like for the rails git repo
+        md = %r{(.+bundler/gems/.+-[a-f0-9]{12})}.match(spec.full_gem_path)
+        spec_git_paths << md[1] if md
+        spec_gem_executables << spec.executables.collect do |executable|
           "#{Gem.dir}/#{spec.bindir}/#{executable}"
         end
-      end.flatten
-      stale_gem_bins = gem_bins - spec_gem_executables
-      stale_git_dirs = git_dirs - spec_gem_paths
-      stale_gem_dirs = gem_dirs - spec_gem_paths
+        spec_cache_paths << spec.cache_file
+        spec_gemspec_paths << spec.spec_file
+        spec_git_cache_dirs << spec.source.cache_path.to_s if spec.source.is_a?(Bundler::Source::Git)
+      end
+      spec_gem_paths.uniq!
+      spec_gem_executables.flatten!
+
+      stale_gem_bins       = gem_bins - spec_gem_executables
+      stale_git_dirs       = git_dirs - spec_git_paths
+      stale_git_cache_dirs = git_cache_dirs - spec_git_cache_dirs
+      stale_gem_dirs       = gem_dirs - spec_gem_paths
+      stale_gem_files      = gem_files - spec_cache_paths
+      stale_gemspec_files  = gemspec_files - spec_gemspec_paths
 
       stale_gem_bins.each {|bin| FileUtils.rm(bin) }
-      stale_gem_dirs.collect do |gem_dir|
+      output = stale_gem_dirs.collect do |gem_dir|
         full_name = Pathname.new(gem_dir).basename.to_s
 
         FileUtils.rm_rf(gem_dir)
-        specification_file = "#{Gem.dir}/specifications/#{full_name}.gemspec"
-        FileUtils.rm(specification_file) if File.exists?(specification_file)
-        gem_file = "#{Gem.dir}/cache/#{full_name}.gem"
-        FileUtils.rm(gem_file) if File.exists?(gem_file)
 
         parts   = full_name.split('-')
         name    = parts[0..-2].join('-')
@@ -168,6 +194,12 @@ module Bundler
 
         output
       end
+
+      stale_gem_files.each {|file| FileUtils.rm(file) if File.exists?(file) }
+      stale_gemspec_files.each {|file| FileUtils.rm(file) if File.exists?(file) }
+      stale_git_cache_dirs.each {|dir| FileUtils.rm_rf(dir) if File.exists?(dir) }
+
+      output
     end
 
   private