bundler 0.9.26 → 1.0.0.beta.1

data/lib/bundler/rubygems_ext.rb

@@ -1,13 +1,79 @@
-unless defined? Gem
-  require 'rubygems'
-  require 'rubygems/specification'
+require 'pathname'
+
+if defined?(Gem::QuickLoader)
+  # Gem Prelude makes me a sad panda :'(
+  Gem::QuickLoader.load_full_rubygems_library
+end
+
+require 'rubygems'
+require 'rubygems/specification'
+
+module Bundler
+  class DepProxy
+
+    attr_reader :required_by, :__platform, :dep
+
+    def initialize(dep, platform)
+      @dep, @__platform, @required_by = dep, platform, []
+    end
+
+    def hash
+      @hash ||= dep.hash
+    end
+
+    def ==(o)
+      dep == o.dep && __platform == o.__platform
+    end
+
+    alias eql? ==
+
+    def type
+      @dep.type
+    end
+
+    def to_s
+      @dep.to_s
+    end
+
+  private
+
+    def method_missing(*args)
+      @dep.send(*args)
+    end
+
+  end
 end
 
 module Gem
   @loaded_stacks = Hash.new { |h,k| h[k] = [] }
 
+  module MatchPlatform
+    def match_platform(p)
+      Gem::Platform::RUBY == platform or
+      platform.nil? or p == platform or
+      Gem::Platform.new(platform).to_generic == p
+    end
+  end
+
   class Specification
-    attr_accessor :source, :location
+    attr_accessor :source, :location, :relative_loaded_from
+
+    alias_method :rg_full_gem_path, :full_gem_path
+    alias_method :rg_loaded_from,   :loaded_from
+
+    include MatchPlatform
+
+    def full_gem_path
+      source.respond_to?(:path) ?
+        Pathname.new(loaded_from).dirname.expand_path.to_s :
+        rg_full_gem_path
+    end
+
+    def loaded_from
+      relative_loaded_from ?
+        source.path.join(relative_loaded_from).to_s :
+        rg_loaded_from
+    end
 
     def load_paths
       require_paths.map do |require_path|
@@ -26,8 +92,7 @@ module Gem
     def git_version
       if @loaded_from && File.exist?(File.join(full_gem_path, ".git"))
         sha = Dir.chdir(full_gem_path){ `git rev-parse HEAD`.strip }
-        branch = full_gem_path.split("-")[3]
-        (branch && branch != sha) ? " #{branch}-#{sha[0...6]}" : " #{sha[0...6]}"
+        " #{sha[0..6]}"
       end
     end
 
@@ -79,8 +144,42 @@ module Gem
   class Dependency
     attr_accessor :source, :groups
 
+    alias eql? ==
+
     def to_yaml_properties
       instance_variables.reject { |p| ["@source", "@groups"].include?(p.to_s) }
     end
+
+    def to_lock
+      out = "  #{name}"
+      unless requirement == Gem::Requirement.default
+        out << " (#{requirement.to_s})"
+      end
+      out
+    end
+  end
+
+  class Platform
+    JAVA  = Gem::Platform.new('java')
+    MSWIN = Gem::Platform.new('mswin32')
+    MING  = Gem::Platform.new('x86-mingw32')
+
+    GENERIC_CACHE = {}
+
+    class << RUBY
+      def to_generic ; self ; end
+    end
+
+    GENERICS = [JAVA, MSWIN, MING, RUBY]
+
+    def hash
+      @cpu.hash + @os.hash + @version.hash
+    end
+
+    alias eql? ==
+
+    def to_generic
+      GENERIC_CACHE[self] ||= GENERICS.find { |p| self =~ p } || RUBY
+    end
   end
 end

data/lib/bundler/runtime.rb

@@ -6,17 +6,16 @@ module Bundler
 
     def initialize(*)
       super
-      write_rb_lock if locked? && !defined?(Bundler::ENV_LOADED)
+      lock
     end
 
     def setup(*groups)
       # Has to happen first
       clean_load_path
 
-      specs = groups.any? ? specs_for(groups) : requested_specs
+      specs = groups.any? ? @definition.specs_for(groups) : requested_specs
 
       cripple_rubygems(specs)
-      replace_rubygems_paths
 
       # Activate the specs
       specs.each do |spec|
@@ -35,37 +34,27 @@ module Bundler
     def require(*groups)
       groups.map! { |g| g.to_sym }
       groups = [:default] if groups.empty?
-      autorequires = autorequires_for_groups(*groups)
-
-      groups.each do |group|
-        (autorequires[group] || [[]]).each do |path, explicit|
-          if explicit
-            Kernel.require(path)
-          else
-            begin
-              Kernel.require(path)
-            rescue LoadError
-            end
+
+      @definition.dependencies.each do |dep|
+        # Skip the dependency if it is not in any of the requested
+        # groups
+        next unless (dep.groups & groups).any?
+
+        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|
+            Kernel.require file
           end
+        rescue LoadError
+          # Only let a LoadError through if the autorequire was explicitly
+          # specified by the user.
+          raise if dep.autorequire
         end
       end
     end
 
-    def dependencies
-      @definition.dependencies
-    end
-
-    def actual_dependencies
-      @definition.actual_dependencies
-    end
-
-    def lock
-      sources.each { |s| s.lock if s.respond_to?(:lock) }
-      FileUtils.mkdir_p("#{root}/.bundle")
-      write_yml_lock
-      write_rb_lock
-    end
-
     def dependencies_for(*groups)
       if groups.empty?
         dependencies
@@ -79,78 +68,31 @@ module Bundler
     def cache
       FileUtils.mkdir_p(cache_path)
 
-      Bundler.ui.info "Copying .gem files into vendor/cache"
+      Bundler.ui.info "Updating .gem files in vendor/cache"
       specs.each do |spec|
-        next unless spec.source.is_a?(Source::SystemGems) || spec.source.is_a?(Source::Rubygems)
-        possibilities = Gem.path.map { |p| "#{p.to_s}/cache/#{spec.full_name}.gem" }
-        cached_path = possibilities.find { |p| File.exist? p }
-        raise GemNotFound, "Missing gem file '#{spec.full_name}.gem'." unless cached_path
-        Bundler.ui.info "  * #{File.basename(cached_path)}"
-        next if File.expand_path(File.dirname(cached_path)) == File.expand_path(cache_path)
-        FileUtils.cp(cached_path, cache_path)
+        spec.source.cache(spec) if spec.source.respond_to?(:cache)
       end
     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.to_s).spec
+        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.to_s)}"
+          Bundler.ui.info "  * #{File.basename(gem_path)}"
           gem_path.rmtree
         end
       end
     end
 
-    private
-
-    def load_paths
-      specs.map { |s| s.load_paths }.flatten
-    end
+  private
 
     def cache_path
       root.join("vendor/cache")
     end
 
-    def write_yml_lock
-      yml = details.to_yaml
-      File.open("#{root}/Gemfile.lock", 'w') do |f|
-        f.puts yml
-      end
-    end
-
-    def details
-      details = {}
-      details["hash"] = gemfile_fingerprint
-      details["sources"] = sources.map { |s| { s.class.name.split("::").last => s.options} }
-
-      details["specs"] = specs.map do |s|
-        options = {"version" => s.version.to_s}
-        options["source"] = sources.index(s.source) if sources.include?(s.source)
-        { s.name => options }
-      end
-
-      details["dependencies"] = @definition.dependencies.inject({}) do |h,d|
-        info = {"version" => d.requirement.to_s, "group" => d.groups}
-        info.merge!("require" => d.autorequire) if d.autorequire
-        h.merge(d.name => info)
-      end
-      details
-    end
-
-    def replace_rubygems_paths
-      Gem.instance_eval do
-        def path
-          [Bundler.bundle_path.to_s]
-        end
-
-        def source_index
-          @source_index ||= Gem::SourceIndex.from_installed_gems
-        end
-      end
-    end
-
   end
 end

data/lib/bundler/settings.rb

@@ -12,16 +12,20 @@ module Bundler
 
     def []=(key, value)
       key = "BUNDLE_#{key.to_s.upcase}"
-      @config[key] = value
-      FileUtils.mkdir_p(config_file.dirname)
-      File.open(config_file, 'w') do |f|
-        f.puts @config.to_yaml
+      unless @config[key] == value
+        @config[key] = value
+        FileUtils.mkdir_p(config_file.dirname)
+        File.open(config_file, 'w') do |f|
+          f.puts @config.to_yaml
+        end
       end
       value
     end
 
     def without=(array)
-      self[:without] = array.join(":")
+      unless array.empty? && without.empty?
+        self[:without] = array.join(":")
+      end
     end
 
     def without

data/lib/bundler/setup.rb

@@ -1,20 +1,12 @@
-# This is not actually required by the actual library
-# loads the bundled environment
 require 'bundler/shared_helpers'
 
 if Bundler::SharedHelpers.in_bundle?
-  env_file = Bundler::SharedHelpers.env_file
-  if env_file.exist?
-    require env_file
-    Bundler.setup if defined?(Bundler::GEM_LOADED)
-  else
-    require 'bundler'
-    begin
-      Bundler.setup
-    rescue Bundler::BundlerError => e
-      puts "\e[31m#{e.message}\e[0m"
-      exit e.status_code
-    end
+  require 'bundler'
+  begin
+    Bundler.setup
+  rescue Bundler::BundlerError => e
+    puts "\e[31m#{e.message}\e[0m"
+    exit e.status_code
   end
 
   # Add bundler to the load path after disabling system gems

data/lib/bundler/shared_helpers.rb

@@ -13,27 +13,6 @@ module Gem
 end
 
 module Bundler
-  class Specification < Gem::Specification
-    attr_accessor :relative_loaded_from
-
-    def self.from_gemspec(gemspec)
-      spec = allocate
-      gemspec.instance_variables.each do |ivar|
-        spec.instance_variable_set(ivar, gemspec.instance_variable_get(ivar))
-      end
-      spec
-    end
-
-    def loaded_from
-      return super unless relative_loaded_from
-      source.path.join(relative_loaded_from).to_s
-    end
-
-    def full_gem_path
-      Pathname.new(loaded_from).dirname.expand_path.to_s
-    end
-  end
-
   module SharedHelpers
     attr_accessor :gem_loaded
 
@@ -47,10 +26,6 @@ module Bundler
       find_gemfile
     end
 
-    def env_file
-      default_gemfile.dirname.join(".bundle/environment.rb")
-    end
-
   private
 
     def find_gemfile
@@ -160,6 +135,8 @@ module Bundler
         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

data/lib/bundler/source.rb

@@ -1,4 +1,5 @@
 require "uri"
+require "rubygems/installer"
 require "rubygems/spec_fetcher"
 require "rubygems/format"
 require "digest/sha1"
@@ -6,178 +7,245 @@ require "open3"
 
 module Bundler
   module Source
+    # TODO: Refactor this class
     class Rubygems
-      attr_reader :uri, :options
+      attr_reader :remotes
 
       def initialize(options = {})
         @options = options
-        @uri = options["uri"].to_s
-        @uri = "#{uri}/" unless @uri =~ %r'/$'
-        @uri = URI.parse(@uri) unless @uri.is_a?(URI)
-        raise ArgumentError, "The source must be an absolute URI" unless @uri.absolute?
+        @remotes = (options["remotes"] || []).map { |r| normalize_uri(r) }
+        @allow_remote = false
+        # Hardcode the paths for now
+        @installed = {}
+        @caches = [ Bundler.app_cache ] + Gem.path.map { |p| File.expand_path("#{p}/cache") }
+        @spec_fetch_map = {}
       end
 
-      def to_s
-        "rubygems repository at #{uri}"
+      def remote!
+        @allow_remote = true
       end
 
-      def specs
-        @specs ||= fetch_specs
+      def [](spec)
+        installed_specs[spec].first ||
+        @allow_remote && (
+          cached_specs[spec].first  ||
+          remote_specs[spec].first)
       end
 
-      def fetch(spec)
-        Bundler.ui.debug "  * Downloading"
-        spec.fetch_platform
-        Gem::RemoteFetcher.fetcher.download(spec, uri, Gem.dir)
+      def hash
+        Rubygems.hash
       end
 
-      def install(spec)
-        Bundler.ui.debug "  * Installing"
-        installer = Gem::Installer.new gem_path(spec),
-          :install_dir         => Gem.dir,
-          :ignore_dependencies => true,
-          :wrappers            => true,
-          :env_shebang         => true,
-          :bin_dir             => "#{Gem.dir}/bin"
+      def eql?(o)
+        Rubygems === o
+      end
 
-        installer.install
+      alias == eql?
 
-        spec.loaded_from = "#{Gem.dir}/specifications/#{spec.full_name}.gemspec"
+      # 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
 
-    private
+      def options
+        { "remotes" => @remotes.map { |r| r.to_s } }
+      end
 
-      def gem_path(spec)
-        "#{Gem.dir}/cache/#{spec.full_name}.gem"
+      def self.from_lock(options)
+        s = new(options)
+        Array(options["remote"]).each { |r| s.add_remote(r) }
+        s
       end
 
-      def fetch_specs
-        index = Index.new
-        Bundler.ui.info "Fetching source index from #{uri}"
-        old, Gem.sources = Gem.sources, ["#{uri}"]
+      def to_lock
+        out = "GEM\n"
+        out << remotes.map {|r| "  remote: #{r}\n" }.join
+        out << "  specs:\n"
+      end
 
-        fetch_all_specs do |n,v|
-          v.each do |name, version, platform|
-            next unless Gem::Platform.match(platform)
-            spec = RemoteSpecification.new(name, version, platform, @uri)
-            spec.source = self
-            index << spec
-          end
-        end
+      def to_s
+        remotes = self.remotes.map { |r| r.to_s }.join(', ')
+        "rubygems repository #{remotes}"
+      end
 
-        index
-      ensure
-        Gem.sources = old
+      def specs
+        @specs ||= @allow_remote ? fetch_specs : installed_specs
       end
 
-      def fetch_all_specs(&blk)
-        # Fetch all specs, minus prerelease specs
-        Gem::SpecFetcher.new.list(true, false).each(&blk)
-        # Then fetch the prerelease specs
-        begin
-          Gem::SpecFetcher.new.list(false, true).each(&blk)
-        rescue Gem::RemoteFetcher::FetchError
-          Bundler.ui.warn "Could not fetch prerelease specs from #{self}"
-        end
+      def fetch(spec)
+        action = @spec_fetch_map[spec.full_name]
+        action.call if action
       end
-    end
 
-    class SystemGems
-      def specs
-        @specs ||= begin
-          index = Index.new
+      def install(spec)
+        path = cached_gem(spec)
 
-          system_paths = Gem::SourceIndex.installed_spec_directories
-          system_paths.reject!{|d| d == Bundler.specs_path.to_s }
+        if @installed[spec.full_name]
+          Bundler.ui.info "Using #{spec.name} (#{spec.version}) "
+          return
+        else
+          Bundler.ui.info "Installing #{spec.name} (#{spec.version}) "
+        end
 
-          system_index = Gem::SourceIndex.from_gems_in(*system_paths)
-          system_index.to_a.reverse.each do |name, spec|
-            spec.source = self
-            index << spec
-          end
+        install_path = Bundler.requires_sudo? ? Bundler.tmp : Gem.dir
+        installer = Gem::Installer.new path,
+          :install_dir         => install_path,
+          :ignore_dependencies => true,
+          :wrappers            => true,
+          :env_shebang         => true,
+          :bin_dir             => "#{install_path}/bin"
+        installer.install
 
-          index
+        # SUDO HAX
+        if Bundler.requires_sudo?
+          sudo "mkdir -p #{Gem.dir}/gems #{Gem.dir}/specifications"
+          sudo "mv #{Bundler.tmp}/gems/#{spec.full_name} #{Gem.dir}/gems/"
+          sudo "mv #{Bundler.tmp}/specifications/#{spec.full_name}.gemspec #{Gem.dir}/specifications/"
         end
+
+        spec.loaded_from = "#{Gem.dir}/specifications/#{spec.full_name}.gemspec"
       end
 
-      def to_s
-        "system gems"
+      def sudo(str)
+        `sudo -E #{str}`
       end
 
-      def install(spec)
-        Bundler.ui.debug "  * already installed; skipping"
+      def cache(spec)
+        cached_path = cached_gem(spec)
+        raise GemNotFound, "Missing gem file '#{spec.full_name}.gem'." unless cached_path
+        return if File.dirname(cached_path) == Bundler.app_cache.to_s
+        Bundler.ui.info "  * #{File.basename(cached_path)}"
+        FileUtils.cp(cached_path, Bundler.app_cache)
       end
-    end
 
-    class BundlerGems < SystemGems
-      def specs
-        @specs ||= begin
-          index = Index.new
+      def add_remote(source)
+        @remotes << normalize_uri(source)
+      end
 
-          bundle_index = Gem::SourceIndex.from_gems_in(Bundler.specs_path)
-          bundle_index.to_a.reverse.each do |name, spec|
-            spec.source = self
-            index << spec
-          end
+    private
 
-          index
-        end
+      def cached_gem(spec)
+        possibilities = @caches.map { |p| "#{p}/#{spec.full_name}.gem" }
+        possibilities.find { |p| File.exist?(p) }
       end
 
-      def to_s
-        "bundler gems"
+      def normalize_uri(uri)
+        uri = uri.to_s
+        uri = "#{uri}/" unless uri =~ %r'/$'
+        uri = URI(uri)
+        raise ArgumentError, "The source must be an absolute URI" unless uri.absolute?
+        uri
       end
-    end
-
-    class GemCache
-      attr_reader :options
 
-      def initialize(options)
-        @options = options
-        @path = options["path"]
+      def fetch_specs
+        Index.build do |idx|
+          idx.use installed_specs
+          idx.use cached_specs
+          idx.use remote_specs
+        end
       end
 
-      def to_s
-        ".gem files at #{@path}"
+      def installed_specs
+        @installed_specs ||= begin
+          idx = Index.new
+          Gem::SourceIndex.from_installed_gems.to_a.reverse.each do |name, spec|
+            @installed[spec.full_name] = true
+            spec.source = self
+            idx << spec
+          end
+          idx
+        end
       end
 
-      def specs
-        @specs ||= begin
-          index = Index.new
+      def cached_specs
+        @cached_specs ||= begin
+          idx = Index.new
+          @caches.each do |path|
+            Dir["#{path}/*.gem"].each do |gemfile|
+              s = Gem::Format.from_file_by_path(gemfile).spec
+              s.source = self
+              idx << s
+            end
+          end
+          idx
+        end
+      end
 
-          Dir["#{@path}/*.gem"].each do |gemfile|
-            spec = Gem::Format.from_file_by_path(gemfile).spec
-            next unless Gem::Platform.match(spec.platform)
-            spec.source = self
-            index << spec
+      def remote_specs
+        @remote_specs ||= begin
+          idx     = Index.new
+          remotes = self.remotes.map { |uri| uri.to_s }
+          old     = Gem.sources
+
+          remotes.each do |uri|
+            Bundler.ui.info "Fetching source index for #{uri}"
+            Gem.sources = ["#{uri}"]
+            fetch_all_remote_specs do |n,v|
+              v.each do |name, version, platform|
+                spec = RemoteSpecification.new(name, version, platform, uri)
+                spec.source = self
+                # Temporary hack until this can be figured out better
+                @spec_fetch_map[spec.full_name] = lambda do
+                  path = download_gem_from_uri(spec, uri)
+                  s = Gem::Format.from_file_by_path(path).spec
+                  spec.__swap__(s)
+                end
+                idx << spec
+              end
+            end
           end
+          idx
+        ensure
+          Gem.sources = old
+        end
+      end
 
-          index
+      def fetch_all_remote_specs(&blk)
+        begin
+          # Fetch all specs, minus prerelease specs
+          Gem::SpecFetcher.new.list(true, false).each(&blk)
+          # Then fetch the prerelease specs
+          begin
+            Gem::SpecFetcher.new.list(false, true).each(&blk)
+          rescue Gem::RemoteFetcher::FetchError
+            Bundler.ui.warn "Could not fetch prerelease specs from #{self}"
+          end
+        rescue Gem::RemoteFetcher::FetchError
+          Bundler.ui.warn "Could not reach #{self}"
         end
       end
 
-      def install(spec)
-        destination = Gem.dir
+      def download_gem_from_uri(spec, uri)
+        spec.fetch_platform
 
-        Bundler.ui.debug "  * Installing from cache"
-        installer = Gem::Installer.new "#{@path}/#{spec.full_name}.gem",
-          :install_dir         => Gem.dir,
-          :ignore_dependencies => true,
-          :wrappers            => true,
-          :env_shebang         => true,
-          :bin_dir             => "#{Gem.dir}/bin"
+        download_path = Bundler.requires_sudo? ? Bundler.tmp : Gem.dir
+        gem_path = "#{Gem.dir}/cache/#{spec.full_name}.gem"
 
-        installer.install
-        spec.loaded_from = "#{Gem.dir}/specifications/#{spec.full_name}.gemspec"
+        FileUtils.mkdir_p("#{download_path}/cache")
+        Gem::RemoteFetcher.fetcher.download(spec, uri, download_path)
+
+        if Bundler.requires_sudo?
+          sudo "mkdir -p #{Gem.dir}/cache"
+          sudo "mv #{Bundler.tmp}/cache/#{spec.full_name}.gem #{gem_path}"
+        end
+
+        gem_path
       end
     end
 
     class Path
       attr_reader :path, :options
+      # Kind of a hack, but needed for the lock file parser
+      attr_accessor :name, :version
+
+      DEFAULT_GLOB = "{,*/}*.gemspec"
 
       def initialize(options)
         @options = options
-        @glob = options["glob"] || "{,*/}*.gemspec"
+        @glob = options["glob"] || DEFAULT_GLOB
+
+        @allow_remote = false
 
         if options["path"]
           @path = Pathname.new(options["path"]).expand_path(Bundler.root)
@@ -187,8 +255,40 @@ module Bundler
         @version = options["version"]
       end
 
+      def remote!
+        @allow_remote = true
+      end
+
+      def self.from_lock(options)
+        new(options.merge("path" => options.delete("remote")))
+      end
+
+      def to_lock
+        out = "PATH\n"
+        out << "  remote: #{relative_path}\n"
+        out << "  glob: #{@glob}\n" unless @glob == DEFAULT_GLOB
+        out << "  specs:\n"
+      end
+
       def to_s
-        "source code at #{@path}"
+        "source at #{@path}"
+      end
+
+      def hash
+        self.class.hash
+      end
+
+      def eql?(o)
+        Path === o     &&
+        path == o.path &&
+        name == o.name &&
+        version == o.version
+      end
+
+      alias == eql?
+
+      def name
+        File.basename(@path.to_s)
       end
 
       def load_spec_files
@@ -213,7 +313,6 @@ module Bundler
             end
 
             if spec
-              spec = Specification.from_gemspec(spec)
               spec.loaded_from = file.to_s
               spec.source = self
               index << spec
@@ -221,10 +320,11 @@ module Bundler
           end
 
           if index.empty? && @name && @version
-            index << Specification.new do |s|
+            index << Gem::Specification.new do |s|
               s.name     = @name
               s.source   = self
               s.version  = Gem::Version.new(@version)
+              s.platform = Gem::Platform::RUBY
               s.summary  = "Fake gemspec for #{@name}"
               s.relative_loaded_from = "#{@name}.gemspec"
               if path.join("bin").exist?
@@ -240,19 +340,53 @@ module Bundler
         index
       end
 
+      def [](spec)
+        specs[spec].first
+      end
+
       def local_specs
         @local_specs ||= load_spec_files
       end
 
+      class Installer < Gem::Installer
+        def initialize(spec)
+          @spec              = spec
+          @bin_dir           = "#{Gem.dir}/bin"
+          @gem_dir           = spec.full_gem_path
+          @wrappers          = true
+          @env_shebang       = true
+          @format_executable = false
+        end
+      end
+
       def install(spec)
-        Bundler.ui.debug "  * Using path #{path}"
-        generate_bin(spec)
+        Bundler.ui.info "Using #{spec.name} (#{spec.version}) from #{to_s} "
+        # Let's be honest, when we're working from a path, we can't
+        # really expect native extensions to work because the whole point
+        # is to just be able to modify what's in that path and go. So, let's
+        # not put ourselves through the pain of actually trying to generate
+        # the full gem.
+        Installer.new(spec).generate_bin
       end
 
       alias specs local_specs
 
+      def cache(spec)
+        unless path.to_s.index(Bundler.root.to_s) == 0
+          Bundler.ui.warn "  * #{spec.name} at `#{path}` will not be cached."
+        end
+      end
+
     private
 
+      def relative_path
+        if path.to_s.include?(Bundler.root.to_s)
+          return path.relative_path_from(Bundler.root)
+        end
+
+        path
+      end
+
       def generate_bin(spec)
         gem_dir  = Pathname.new(spec.full_gem_path)
 
@@ -302,32 +436,68 @@ module Bundler
 
       def initialize(options)
         super
-        @uri    = options["uri"]
-        @ref    = options["ref"] || options["branch"] || options["tag"] || 'master'
+        @uri      = options["uri"]
+        @ref      = options["ref"] || options["branch"] || options["tag"] || 'master'
+        @revision = options["revision"]
+        @update   = false
+      end
+
+      def self.from_lock(options)
+        new(options.merge("uri" => options.delete("remote")))
+      end
+
+      def to_lock
+        out = "GIT\n"
+        out << "  remote: #{@uri}\n"
+        out << "  revision: #{shortref_for(revision)}\n"
+        %w(ref branch tag).each do |opt|
+          out << "  #{opt}: #{options[opt]}\n" if options[opt]
+        end
+        out << "  glob: #{@glob}\n" unless @glob == DEFAULT_GLOB
+        out << "  specs:\n"
       end
 
+      def eql?(o)
+        Git === o            &&
+        uri == o.uri         &&
+        ref == o.ref         &&
+        name == o.name       &&
+        version == o.version
+      end
+
+      alias == eql?
+
       def to_s
-        ref = @options["ref"] ? @options["ref"][0..6] : @ref
+        ref = @options["ref"] ? shortref_for(@options["ref"]) : @ref
         "#{@uri} (at #{ref})"
       end
 
+      def name
+        File.basename(@uri, '.git')
+      end
+
       def path
-        Bundler.install_path.join("#{base_name}-#{uri_hash}-#{ref}")
+        Bundler.install_path.join("#{base_name}-#{shortref_for(revision)}")
+      end
+
+      def unlock!
+        @revision = nil
       end
 
       def specs
+        if @allow_remote && !@update
         # Start by making sure the git cache is up to date
-        cache
-        checkout
+          cache
+          checkout
+          @update = true
+        end
         local_specs
       end
 
       def install(spec)
-        Bundler.ui.debug "  * Using git #{uri}"
+        Bundler.ui.info "Using #{spec.name} (#{spec.version}) from #{to_s} "
 
-        if @installed
-          Bundler.ui.debug "  * Already checked out revision: #{ref}"
-        else
+        unless @installed
           Bundler.ui.debug "  * Checking out revision: #{ref}"
           checkout
           @installed = true
@@ -335,11 +505,6 @@ module Bundler
         generate_bin(spec)
       end
 
-      def lock
-        @ref = @options["ref"] = revision
-        checkout
-      end
-
       def load_spec_files
         super
       rescue PathError
@@ -349,7 +514,12 @@ module Bundler
     private
 
       def git(command)
-        out = %x{git #{command}}
+        if Bundler.requires_sudo?
+          out = %x{sudo -E git #{command}}
+        else
+          out = %x{git #{command}}
+        end
+
         if $? != 0
           raise GitError, "An error has occurred in git. Cannot complete bundling."
         end
@@ -360,6 +530,10 @@ module Bundler
         File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)},''), ".git")
       end
 
+      def shortref_for(ref)
+        ref[0..6]
+      end
+
       def uri_hash
         if uri =~ %r{^\w+://(\w+@)?}
           # Downcase the domain component of the URI