bundler 1.0.22 → 1.1.pre

data/lib/bundler/lazy_specification.rb

@@ -36,7 +36,7 @@ module Bundler
         out = "    #{name} (#{version}-#{platform})\n"
       end
 
-      dependencies.sort_by {|d| d.to_s }.each do |dep|
+      dependencies.sort_by {|d| d.name }.each do |dep|
         next if dep.type == :development
         out << "    #{dep.to_lock}\n"
       end
@@ -58,16 +58,13 @@ module Bundler
 
   private
 
-    def to_ary
-      nil
-    end
-
     def method_missing(method, *args, &blk)
-      raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
-
-      return super unless respond_to?(method)
-
-      @specification.send(method, *args, &blk)
+      if Gem::Specification.new.respond_to?(method)
+        raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
+        @specification.send(method, *args, &blk)
+      else
+        super
+      end
     end
 
   end

data/lib/bundler/remote_specification.rb

@@ -12,11 +12,11 @@ module Bundler
     attr_reader :name, :version, :platform
     attr_accessor :source
 
-    def initialize(name, version, platform, source_uri)
-      @name     = name
-      @version  = version
-      @platform = platform
-      @source_uri = source_uri
+    def initialize(name, version, platform, spec_fetcher)
+      @name         = name
+      @version      = version
+      @platform     = platform
+      @spec_fetcher = spec_fetcher
     end
 
     # Needed before installs, since the arch matters then and quick
@@ -43,9 +43,7 @@ module Bundler
   private
 
     def _remote_specification
-      @specification ||= begin
-        Gem::SpecFetcher.new.fetch_spec([@name, @version, @platform], URI(@source_uri.to_s))
-      end
+      @specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
     end
 
     def method_missing(method, *args, &blk)

data/lib/bundler/resolver.rb

@@ -145,7 +145,7 @@ module Bundler
     def debug
       if ENV['DEBUG_RESOLVER']
         debug_info = yield
-        debug_info = debug_info.inspect unless debug_info.is_a?(String)
+        debug_info = debug_info.inpsect unless debug_info.is_a?(String)
         $stderr.puts debug_info
       end
     end
@@ -179,15 +179,15 @@ module Bundler
           activated[a.name] ? 0 : gems_size(a) ]
       end
 
-      debug { "Activated:\n" + activated.values.map {|a| "  #{a}" }.join("\n") }
-      debug { "Requirements:\n" + reqs.map {|r| "  #{r}"}.join("\n") }
+      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") }
 
       activated = activated.dup
 
       # Pull off the first requirement so that we can resolve it
       current = reqs.shift
 
-      debug { "Attempting:\n  #{current}"}
+      debug { "Attempting:\n  #{current.name} (#{current.requirement})"}
 
       # Check if the gem has already been activated, if it has, we will make sure
       # that the currently activated gem satisfies the requirement.
@@ -279,6 +279,14 @@ module Bundler
             end
             raise GemNotFound, message
           else
+            if @missing_gems[current] >= 5
+              message =  "Bundler could not find find gem #{current.required_by.last},"
+              message << "which is required by gem #{current}."
+              raise GemNotFound, message
+            end
+            @missing_gems[current] += 1
+
+            debug { "    Could not find #{current} by #{current.required_by.last}" }
             @errors[current.name] = [nil, current]
           end
         end
@@ -348,8 +356,7 @@ module Bundler
 
     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)
+        d = Gem::Dependency.new(base.first.name, *[dep.requirement.as_list, base.first.version].flatten)
       else
         d = dep.dep
       end
@@ -413,7 +420,7 @@ module Bundler
           # If the origin is "bundler", the conflict is us
           if origin.name == "bundler"
             o << "  Current Bundler version:\n"
-            other_bundler_required = !requirement.requirement.satisfied_by?(origin.version)
+            newer_bundler_required = requirement.requirement > Gem::Requirement.new(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"
@@ -422,9 +429,9 @@ module Bundler
           o << gem_message(origin)
 
           # If the bundle wants a newer bundler than the running bundler, explain
-          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`?"
+          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
@@ -449,8 +456,7 @@ module Bundler
           # the rest of the time, the gem cannot be found because it does not exist in the known sources
           else
             if requirement.required_by.first
-              o << "Could not find gem '#{clean_req(requirement)}', which is required by "
-              o << "gem '#{clean_req(requirement.required_by.first)}', in any of the sources."
+              o << "Could not find gem '#{clean_req(requirement)}', required by '#{clean_req(requirement.required_by.first)}', in any of the sources\n"
             else
               o << "Could not find gem '#{clean_req(requirement)} in any of the sources\n"
             end

data/lib/bundler/rubygems_ext.rb

@@ -19,7 +19,7 @@ module Gem
 
     def full_gem_path
       source.respond_to?(:path) ?
-        Pathname.new(loaded_from).dirname.expand_path(Bundler.root).to_s :
+        Pathname.new(loaded_from).dirname.expand_path.to_s :
         rg_full_gem_path
     end
 
@@ -39,12 +39,6 @@ module Gem
       end
     end
 
-    # RubyGems 1.8+ used only.
-    remove_method :gem_dir if method_defined? :gem_dir
-    def gem_dir
-      full_gem_path
-    end
-
     def groups
       @groups ||= []
     end
@@ -111,12 +105,6 @@ module Gem
 
     alias eql? ==
 
-    def encode_with(coder)
-      to_yaml_properties.each do |ivar|
-        coder[ivar.to_s.sub(/^@/, '')] = instance_variable_get(ivar)
-      end
-    end
-
     def to_yaml_properties
       instance_variables.reject { |p| ["@source", "@groups"].include?(p.to_s) }
     end
@@ -124,13 +112,11 @@ module Gem
     def to_lock
       out = "  #{name}"
       unless requirement == Gem::Requirement.default
-        reqs = requirement.requirements.map{|o,v| "#{o} #{v}" }.sort.reverse
-        out << " (#{reqs.join(', ')})"
+        out << " (#{requirement.to_s})"
       end
       out
     end
 
-    # Backport of performance enhancement added to Rubygems 1.4
     def matches_spec?(spec)
       # name can be a Regexp, so use ===
       return false unless name === spec.name
@@ -141,7 +127,6 @@ module Gem
   end
 
   class Requirement
-    # Backport of performance enhancement added to Rubygems 1.4
     def none?
       @none ||= (to_s == ">= 0")
     end unless allocate.respond_to?(:none?)
@@ -152,14 +137,12 @@ 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
 
     alias eql? ==
   end
-
 end
 
 module Bundler
@@ -186,7 +169,7 @@ module Bundler
     end
 
     def to_s
-      "#{name} (#{requirement}) #{__platform}"
+      @dep.to_s
     end
 
   private

data/lib/bundler/runtime.rb

@@ -11,7 +11,7 @@ module Bundler
       specs = groups.any? ? @definition.specs_for(groups) : requested_specs
 
       setup_environment
-      Bundler.rubygems.replace_entrypoints(specs)
+      cripple_rubygems(specs)
 
       # Activate the specs
       specs.each do |spec|
@@ -19,9 +19,9 @@ module Bundler
           raise GemNotFound, "#{spec.full_name} is missing. Run `bundle` to get it."
         end
 
-        if activated_spec = Bundler.rubygems.loaded_specs(spec.name) and activated_spec.version != spec.version
+        if activated_spec = Gem.loaded_specs[spec.name] and activated_spec.version != spec.version
           e = Gem::LoadError.new "You have already activated #{activated_spec.name} #{activated_spec.version}, " \
-                                 "but your Gemfile requires #{spec.name} #{spec.version}. Using bundle exec may solve this."
+                                 "but your Gemfile requires #{spec.name} #{spec.version}. Consider using bundle exec."
           e.name = spec.name
           if e.respond_to?(:requirement=)
             e.requirement = Gem::Requirement.new(spec.version.to_s)
@@ -31,7 +31,7 @@ module Bundler
           raise e
         end
 
-        Bundler.rubygems.mark_loaded(spec)
+        Gem.loaded_specs[spec.name] = spec
         load_paths = spec.load_paths.reject {|path| $LOAD_PATH.include?(path)}
         $LOAD_PATH.unshift(*load_paths)
       end
@@ -85,7 +85,7 @@ module Bundler
     alias gems specs
 
     def cache
-      FileUtils.mkdir_p(cache_path) unless File.exists?(cache_path)
+      FileUtils.mkdir_p(cache_path)
 
       Bundler.ui.info "Updating .gem files in vendor/cache"
       specs.each do |spec|
@@ -96,13 +96,13 @@ module Bundler
     end
 
     def prune_cache
-      FileUtils.mkdir_p(cache_path) unless File.exists?(cache_path)
+      FileUtils.mkdir_p(cache_path)
 
       resolve = @definition.resolve
       cached  = Dir["#{cache_path}/*.gem"]
 
       cached = cached.delete_if do |path|
-        spec = Bundler.rubygems.spec_from_gem path
+        spec = Gem::Format.from_file_by_path(path).spec
 
         resolve.any? do |s|
           s.name == spec.name && s.version == spec.version && !s.source.is_a?(Bundler::Source::Git)
@@ -119,6 +119,55 @@ module Bundler
       end
     end
 
+    def clean
+      return false if Bundler.settings[:path] == nil
+
+      gem_bins             = Dir["#{Gem.dir}/bin/*"]
+      git_dirs             = Dir["#{Gem.dir}/bundler/gems/*"]
+      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.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
+
+      stale_gem_bins.each {|bin| FileUtils.rm(bin) }
+      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)
+
+        parts   = full_name.split('-')
+        name    = parts[0..-2].join('-')
+        version = parts.last
+        output  = "#{name} (#{version})"
+
+        Bundler.ui.info "Removing #{output}"
+
+        output
+      end + stale_git_dirs.collect do |gem_dir|
+        full_name = Pathname.new(gem_dir).basename.to_s
+
+        FileUtils.rm_rf(gem_dir)
+
+        parts    = full_name.split('-')
+        name     = parts[0..-3].join('-')
+        revision = parts[-1]
+        version  = parts[-2]
+        output   = "#{name} (#{version} #{revision})"
+
+        Bundler.ui.info "Removing #{output}"
+
+        output
+      end
+    end
+
   private
 
     def cache_path
@@ -127,7 +176,7 @@ module Bundler
 
     def setup_environment
       begin
-        ENV["BUNDLE_BIN_PATH"] = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
+        ENV["BUNDLE_BIN_PATH"] = Gem.bin_path("bundler", "bundle", VERSION)
       rescue Gem::GemNotFoundException
         ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../bin/bundle", __FILE__)
       end

data/lib/bundler/settings.rb

@@ -16,7 +16,7 @@ module Bundler
     end
 
     def delete(key)
-      @local_config.delete(key_for(key))
+      @local_config
     end
 
     def set_global(key, value)
@@ -62,7 +62,9 @@ module Bundler
     end
 
     def without=(array)
-      self[:without] = (array.empty? ? nil : array.join(":")) if array
+      unless array.empty?
+        self[:without] = array.join(":")
+      end
     end
 
     def without
@@ -77,7 +79,7 @@ module Bundler
       if path = self[:path]
         "#{path}/#{Bundler.ruby_scope}"
       else
-        Bundler.rubygems.gem_dir
+        Gem.dir
       end
     end
 
@@ -104,7 +106,7 @@ module Bundler
     end
 
     def global_config_file
-      file = ENV["BUNDLE_CONFIG"] || File.join(Bundler.rubygems.user_home, ".bundle/config")
+      file = ENV["BUNDLE_CONFIG"] || File.join(Gem.user_home, ".bundle/config")
       Pathname.new(file)
     end
 

data/lib/bundler/setup.rb

@@ -2,19 +2,12 @@ require 'bundler/shared_helpers'
 
 if Bundler::SharedHelpers.in_bundle?
   require 'bundler'
-  if STDOUT.tty?
-    begin
-      Bundler.setup
-    rescue Bundler::BundlerError => e
-      puts "\e[31m#{e.message}\e[0m"
-      puts e.backtrace.join("\n") if ENV["DEBUG"]
-      if Bundler::GemNotFound === e
-        puts "\e[33mRun `bundle install` to install missing gems.\e[0m"
-      end
-      exit e.status_code
-    end
-  else
+  begin
     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
 
   # Add bundler to the load path after disabling system gems

data/lib/bundler/shared_helpers.rb

@@ -1,7 +1,6 @@
 require 'pathname'
 require 'rubygems'
-
-require 'bundler/rubygems_integration'
+Gem.source_index # ensure Rubygems is fully loaded in Ruby 1.9
 
 module Gem
   class Dependency
@@ -58,14 +57,111 @@ module Bundler
       if defined?(::Gem)
         me = File.expand_path("../../", __FILE__)
         $LOAD_PATH.reject! do |p|
-          next if File.expand_path(p) =~ /^#{Regexp.escape(me)}/
+          next if File.expand_path(p) =~ /^#{me}/
           p != File.dirname(__FILE__) &&
-            Bundler.rubygems.gem_path.any?{|gp| p =~ /^#{Regexp.escape(gp)}/ }
+            Gem.path.any?{|gp| p =~ /^#{gp}/ }
         end
         $LOAD_PATH.uniq!
       end
     end
 
+    def reverse_rubygems_kernel_mixin
+      # Disable rubygems' gem activation system
+      ::Kernel.class_eval do
+        if private_method_defined?(:gem_original_require)
+          alias rubygems_require require
+          alias require gem_original_require
+        end
+
+        undef gem
+      end
+    end
+
+    def cripple_rubygems(specs)
+      reverse_rubygems_kernel_mixin
+
+      executables = specs.map { |s| s.executables }.flatten
+      Gem.source_index # ensure RubyGems is fully loaded
+
+      ::Kernel.send(:define_method, :gem) do |dep, *reqs|
+        if executables.include? File.basename(caller.first.split(':').first)
+          return
+        end
+        opts = reqs.last.is_a?(Hash) ? reqs.pop : {}
+
+        unless dep.respond_to?(:name) && dep.respond_to?(:requirement)
+          dep = Gem::Dependency.new(dep, reqs)
+        end
+
+        spec = specs.find  { |s| s.name == dep.name }
+
+        if spec.nil?
+
+          e = Gem::LoadError.new "#{dep.name} is not part of the bundle. Add it to Gemfile."
+          e.name = dep.name
+          if e.respond_to?(:requirement=)
+            e.requirement = dep.requirement
+          else
+            e.version_requirement = dep.requirement
+          end
+          raise e
+        elsif dep !~ spec
+          e = Gem::LoadError.new "can't activate #{dep}, already activated #{spec.full_name}. " \
+                                 "Make sure all dependencies are added to Gemfile."
+          e.name = dep.name
+          if e.respond_to?(:requirement=)
+            e.requirement = dep.requirement
+          else
+            e.version_requirement = dep.requirement
+          end
+          raise e
+        end
+
+        true
+      end
+
+      # === Following hacks are to improve on the generated bin wrappers ===
+
+      # Yeah, talk about a hack
+      source_index_class = (class << Gem::SourceIndex ; self ; end)
+      source_index_class.send(:remove_method, :from_gems_in)
+      source_index_class.send(:define_method, :from_gems_in) do |*args|
+        source_index = Gem::SourceIndex.new
+        source_index.spec_dirs = *args
+        source_index.add_specs(*specs)
+        source_index
+      end
+
+      # OMG more hacks
+      gem_class = (class << Gem ; self ; end)
+      gem_class.send(:remove_method, :refresh)
+      gem_class.send(:define_method, :refresh) { }
+      gem_class.send(:remove_method, :bin_path)
+      gem_class.send(:define_method, :bin_path) do |name, *args|
+        exec_name, *reqs = args
+
+        if exec_name == 'bundle'
+          return ENV['BUNDLE_BIN_PATH']
+        end
+
+        spec = nil
+
+        if exec_name
+          spec = specs.find { |s| s.executables.include?(exec_name) }
+          spec or raise Gem::Exception, "can't find executable #{exec_name}"
+        else
+          spec = specs.find  { |s| s.name == name }
+          exec_name = spec.default_executable or raise Gem::Exception, "no default executable for #{spec.full_name}"
+        end
+
+        gem_bin = File.join(spec.full_gem_path, spec.bindir, exec_name)
+        gem_from_path_bin = File.join(File.dirname(spec.loaded_from), spec.bindir, exec_name)
+        File.exist?(gem_bin) ? gem_bin : gem_from_path_bin
+      end
+
+      Gem.clear_paths
+    end
+
     extend self
   end
 end