bundler 1.1.pre.1 → 1.1.pre.2

data/lib/bundler/installer.rb

@@ -10,8 +10,16 @@ module Bundler
     end
 
     def run(options)
+      # Create the BUNDLE_PATH directory
+      begin
+        Bundler.bundle_path.mkpath unless Bundler.bundle_path.exist?
+      rescue Errno::EEXIST
+        raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " +
+          "because of an invalid symlink. Remove the symlink so the directory can be created."
+      end
+
       if Bundler.settings[:frozen]
-        @definition.ensure_equivalent_gemfile_and_lockfile
+        @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
       end
 
       if dependencies.empty?
@@ -35,9 +43,6 @@ module Bundler
           @definition.resolve_remotely!
       end
 
-      # Ensure that BUNDLE_PATH exists
-      Bundler.mkdir_p(Bundler.bundle_path) unless File.exist?(Bundler.bundle_path)
-
       # Must install gems in the order that the resolver provides
       # as dependencies might actually affect the installation of
       # the gem.
@@ -49,13 +54,9 @@ module Bundler
         #   next
         # end
 
-        begin
-          old_args = Gem::Command.build_args
-          Gem::Command.build_args = [Bundler.settings["build.#{spec.name}"]]
+        Bundler.rubygems.with_build_args [Bundler.settings["build.#{spec.name}"]] do
           spec.source.install(spec)
           Bundler.ui.debug "from #{spec.loaded_from} "
-        ensure
-          Gem::Command.build_args = old_args
         end
 
         Bundler.ui.info ""

data/lib/bundler/lazy_specification.rb

@@ -36,7 +36,7 @@ module Bundler
         out = "    #{name} (#{version}-#{platform})\n"
       end
 
-      dependencies.sort_by {|d| d.name }.each do |dep|
+      dependencies.sort_by {|d| d.to_s }.each do |dep|
         next if dep.type == :development
         out << "    #{dep.to_lock}\n"
       end

data/lib/bundler/resolver.rb

@@ -271,7 +271,7 @@ module Bundler
               end
             else
               message = "Could not find gem '#{current}' "
-              if @index.sources.include?(Bundler::Source::Rubygems)
+              if @index.source_types.include?(Bundler::Source::Rubygems)
                 message << "in any of the gem sources listed in your Gemfile."
               else
                 message << "in the gems available on this machine."

data/lib/bundler/rubygems_ext.rb

@@ -64,22 +64,6 @@ module Gem
       dependencies - development_dependencies
     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)
-          self.add_development_dependency(dep.name, dep.requirement.to_s)
-        elsif (dep.groups & groups).any?
-          self.add_dependency(dep.name, dep.requirement.to_s)
-        end
-      end
-    end
-
   private
 
     def dependencies_to_gemfile(dependencies, group = nil)
@@ -118,11 +102,13 @@ module Gem
     def to_lock
       out = "  #{name}"
       unless requirement == Gem::Requirement.default
-        out << " (#{requirement.to_s})"
+        reqs = requirement.requirements.map{|o,v| "#{o} #{v}" }
+        out << " (#{reqs.join(', ')})"
       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
@@ -133,6 +119,7 @@ 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?)

data/lib/bundler/rubygems_integration.rb

@@ -0,0 +1,301 @@
+module Bundler
+  class RubygemsIntegration
+    def initialize
+      # Work around a RubyGems bug
+      configuration
+    end
+
+    def is_19?
+      false
+    end
+
+    # Make sure that rubygems has fully loaded (1.9 partially loads
+    # sometimes)
+    def fully_load!
+      Gem.source_index if is_19?
+    end
+
+    def loaded_specs(name)
+      Gem.loaded_specs[name]
+    end
+
+    def mark_loaded(spec)
+      Gem.loaded_specs[spec.name] = spec
+    end
+
+    def path(obj)
+      Gem::Path.path(obj)
+    end
+
+    def platforms
+      Gem.platforms
+    end
+
+    def configuration
+      Gem.configuration
+    end
+
+    def ruby_engine
+      Gem.ruby_engine
+    end
+
+    def read_binary(path)
+      Gem.read_binary(path)
+    end
+
+    def inflate(obj)
+      Gem.inflate(obj)
+    end
+
+    def sources=(val)
+      Gem.sources = val
+    end
+
+    def sources
+      Gem.sources
+    end
+
+    def gem_dir
+      Gem.dir.to_s
+    end
+
+    def gem_bindir
+      Gem.bindir
+    end
+
+    def user_home
+      Gem.user_home
+    end
+
+    def gem_path
+      Gem.path.to_s
+    end
+
+    def marshal_spec_dir
+      Gem::MARSHAL_SPEC_DIR
+    end
+
+    def clear_paths
+      Gem.clear_paths
+    end
+
+    def bin_path(gem, bin, ver)
+      Gem.bin_path(gem, bin, ver)
+    end
+
+    def ui=(obj)
+      Gem::DefaultUserInteraction.ui = obj
+    end
+
+    def fetch_specs(all, pre, &blk)
+      Gem::SpecFetcher.new.list(all, pre).each(&blk)
+    end
+
+    def with_build_args(args)
+      old_args = Gem::Command.build_args
+      begin
+        Gem::Command.build_args = args
+        yield
+      ensure
+        Gem::Command.build_args = old_args
+      end
+    end
+
+    def spec_from_gem(path)
+      Gem::Format.from_file_by_path(path).spec
+    end
+
+    def download_gem(spec, uri, path)
+      Gem::RemoteFetcher.fetcher.download(spec, uri, path)
+    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 replace_gem(specs)
+      executables = specs.map { |s| s.executables }.flatten
+
+      ::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
+    end
+
+    def stub_source_index137(specs)
+      # Rubygems versions lower than 1.7 use SourceIndex#from_gems_in
+      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
+    end
+
+    def stub_source_index170(specs)
+      Gem::SourceIndex.send(:define_method, :initialize) do |*args|
+        @gems = {}
+        self.spec_dirs = *args
+        add_specs(*specs)
+      end
+    end
+
+    # Used to make bin stubs that are not created by bundler work
+    # under bundler. The new Gem.bin_path only considers gems in
+    # +specs+
+    def replace_bin_path(specs)
+      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
+
+        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
+    end
+
+    # Because Bundler has a static view of what specs are available,
+    # we don't #reflesh, so stub it out.
+    def replace_refresh
+      gem_class = (class << Gem ; self ; end)
+      gem_class.send(:remove_method, :refresh)
+      gem_class.send(:define_method, :refresh) { }
+    end
+
+    # Replace or hook into Rubygems to provide a bundlerized view
+    # of the world.
+    def replace_entrypoints(specs)
+      reverse_rubygems_kernel_mixin
+
+      replace_gem(specs)
+
+      stub_rubygems(specs)
+
+      replace_bin_path(specs)
+      replace_refresh
+
+      Gem.clear_paths
+    end
+
+    class Modern < RubygemsIntegration
+      def stub_rubygems(specs)
+        Gem::Specification.all = specs
+
+        Gem.post_reset {
+          Gem::Specification.all = specs
+        }
+
+        stub_source_index170(specs)
+      end
+
+      def all_specs
+        Gem::Specification.to_a
+      end
+
+      def find_name(name)
+        Gem::Specification.find_all_by_name name
+      end
+
+    end
+
+    class Legacy < RubygemsIntegration
+      def stub_rubygems(specs)
+        stub_source_index137(specs)
+      end
+
+      def path(obj)
+        obj.to_s
+      end
+
+      def all_specs
+        Gem.source_index.all_gems.values
+      end
+
+      def find_name(name)
+        Gem.source_index.find_name(name)
+      end
+    end
+
+    class Transitional < Legacy
+      def stub_rubygems(specs)
+        stub_source_index170(specs)
+      end
+
+      def path(obj)
+        obj.to_s
+      end
+    end
+
+  end
+
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.7.0')
+    if Gem::Specification.respond_to? :all=
+      @rubygems = RubygemsIntegration::Modern.new
+    else
+      @rubygems = RubygemsIntegration::Transitional.new
+    end
+  else
+    @rubygems = RubygemsIntegration::Legacy.new
+  end
+
+  class << self
+    attr_reader :rubygems
+  end
+end

data/lib/bundler/runtime.rb

@@ -11,7 +11,7 @@ module Bundler
       specs = groups.any? ? @definition.specs_for(groups) : requested_specs
 
       setup_environment
-      cripple_rubygems(specs)
+      Bundler.rubygems.replace_entrypoints(specs)
 
       # Activate the specs
       specs.each do |spec|
@@ -19,7 +19,7 @@ module Bundler
           raise GemNotFound, "#{spec.full_name} is missing. Run `bundle` to get it."
         end
 
-        if activated_spec = Gem.loaded_specs[spec.name] and activated_spec.version != spec.version
+        if activated_spec = Bundler.rubygems.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}. Consider using bundle exec."
           e.name = spec.name
@@ -31,7 +31,7 @@ module Bundler
           raise e
         end
 
-        Gem.loaded_specs[spec.name] = spec
+        Bundler.rubygems.mark_loaded(spec)
         load_paths = spec.load_paths.reject {|path| $LOAD_PATH.include?(path)}
         $LOAD_PATH.unshift(*load_paths)
       end
@@ -102,7 +102,7 @@ module Bundler
       cached  = Dir["#{cache_path}/*.gem"]
 
       cached = cached.delete_if do |path|
-        spec = Gem::Format.from_file_by_path(path).spec
+        spec = Bundler.rubygems.spec_from_gem path
 
         resolve.any? do |s|
           s.name == spec.name && s.version == spec.version && !s.source.is_a?(Bundler::Source::Git)
@@ -176,7 +176,7 @@ module Bundler
 
     def setup_environment
       begin
-        ENV["BUNDLE_BIN_PATH"] = Gem.bin_path("bundler", "bundle", VERSION)
+        ENV["BUNDLE_BIN_PATH"] = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
       rescue Gem::GemNotFoundException
         ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../bin/bundle", __FILE__)
       end