rr 1.1.1 → 3.0.0

data/lib/rr/space.rb

@@ -13,9 +13,15 @@ module RR
       end
       attr_writer :instance
 
-    protected
-      def method_missing(method_name, *args, &block)
-        instance.__send__(method_name, *args, &block)
+      protected
+      if KeywordArguments.fully_supported?
+        def method_missing(method_name, *args, **kwargs, &block)
+          instance.__send__(method_name, *args, **kwargs, &block)
+        end
+      else
+        def method_missing(method_name, *args, &block)
+          instance.__send__(method_name, *args, &block)
+        end
       end
     end
 
@@ -79,8 +85,12 @@ module RR
       Injections::DoubleInjection.reset_double(class << subject; self; end, method_name)
     end
 
-    def record_call(subject, method_name, arguments, block)
-      @recorded_calls << [subject, method_name, arguments, block]
+    def record_call(subject, method_name, arguments, keyword_arguments, block)
+      @recorded_calls.add(subject,
+                          method_name,
+                          arguments,
+                          keyword_arguments,
+                          block)
     end
 
     def blank_slate_whitelist

data/lib/rr/spy_verification.rb

@@ -13,12 +13,12 @@ module RR
 
     include RR::DoubleDefinitions::DoubleDefinition::TimesDefinitionConstructionMethods
     include RR::DoubleDefinitions::DoubleDefinition::ArgumentDefinitionConstructionMethods
-  
+
     def ordered
       @ordered = true
       self
     end
-  
+
     def ordered?
       @ordered
     end
@@ -32,7 +32,15 @@ module RR
         call
       end
     end
-  
+
+    def subject_inspect
+      if subject.respond_to?(:__rr__original_inspect, true)
+        subject.__rr__original_inspect
+      else
+        subject.inspect
+      end
+    end
+
   protected
     attr_writer :times_matcher
 
@@ -40,9 +48,9 @@ module RR
       # with_no_args and with actually set @argument_expectation
       args.empty? ? with_no_args : with(*args)
     end
-  
+
     def install_method_callback(return_value_block)
       # Do nothing. This is to support DefinitionConstructionMethods
     end
   end
-end
+end

data/lib/rr/version.rb

@@ -1,5 +1,4 @@
-
 module RR
-  VERSION = File.read(File.expand_path('../../../VERSION', __FILE__)).strip
+  VERSION = '3.0.0'.freeze
   def self.version; VERSION; end
 end

data/lib/rr/wildcard_matchers.rb

@@ -12,7 +12,7 @@ divisible by a certain integer.  In use, it might look like this:
 
   mock(BananaGrabber).bunch_bananas(divisible_by(5))
 
-To implement this, we need a class RR::WildcardMatchers::DivisibleBy with 
+To implement this, we need a class RR::WildcardMatchers::DivisibleBy with
 these instance methods:
 
 * ==(other)
@@ -38,7 +38,7 @@ might look like this:
 DivisibleBy#==(other) should return true if other is a wildcard matcher that
 matches the same things as self, so a natural way to write DivisibleBy#== is:
 
-  
+
   class RR::WildcardMatchers::DivisibleBy
     def ==(other)
       # Ensure that other is actually a DivisibleBy
@@ -86,7 +86,7 @@ false otherwise.  In the case of DivisibleBy, wildcard_matches? reads:
       # If other isn't a number, how can it be divisible by anything?
       return false unless other.is_a?(Numeric)
 
-      # If other is in fact divisible by expected_divisor, then 
+      # If other is in fact divisible by expected_divisor, then
       # other modulo expected_divisor should be 0.
 
       other % expected_divisor == 0
@@ -105,10 +105,10 @@ But that's less expressive than the original:
   mock(BananaGrabber).bunch_bananas(divisible_by(5))
 
 To be able to use the convenient divisible_by matcher rather than the uglier
-DivisibleBy.new version, re-open the module RR::Adapters::RRMethods and
-define divisible_by there as a simple wrapper around DivisibleBy.new:
+DivisibleBy.new version, re-open the module RR::DSL and define divisible_by
+there as a simple wrapper around DivisibleBy.new:
 
-  module RR::Adapters::RRMethods
+  module RR::DSL
     def divisible_by(expected_divisor)
       RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
     end
@@ -134,19 +134,19 @@ Here's all the code for DivisibleBy in one place for easy reference:
     def inspect
       "integer divisible by #{expected.divisor}"
     end
-  
+
     def wildcard_matches?(other)
       # If other isn't a number, how can it be divisible by anything?
       return false unless other.is_a?(Numeric)
 
-      # If other is in fact divisible by expected_divisor, then 
+      # If other is in fact divisible by expected_divisor, then
       # other modulo expected_divisor should be 0.
 
       other % expected_divisor == 0
     end
   end
-  
-  module RR::Adapters::RRMethods
+
+  module RR::DSL
     def divisible_by(expected_divisor)
       RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
     end

data/lib/rr/without_autohook.rb

@@ -6,6 +6,8 @@ require 'rr/core_ext/array'
 require 'rr/core_ext/range'
 require 'rr/core_ext/regexp'
 
+require 'rr/keyword_arguments'
+
 require 'rr/class_instance_method_defined'
 require 'rr/blank_slate'
 
@@ -36,7 +38,7 @@ require 'rr/double_definitions/strategies/implementation/proxy'
 require 'rr/double_definitions/strategies/double_injection/double_injection_strategy'
 require 'rr/double_definitions/strategies/double_injection/instance'
 require 'rr/double_definitions/strategies/double_injection/any_instance_of'
-require 'rr/adapters/rr_methods'
+require 'rr/dsl'
 require 'rr/double_definitions/double_injections/instance'
 require 'rr/double_definitions/double_injections/any_instance_of'
 require 'rr/double_definitions/double_definition'
@@ -49,8 +51,8 @@ require 'rr/method_dispatches/base_method_dispatch'
 require 'rr/method_dispatches/method_dispatch'
 require 'rr/method_dispatches/method_missing_dispatch'
 require 'rr/hash_with_object_id_key'
+require 'rr/recorded_call'
 require 'rr/recorded_calls'
-require 'rr/proc_from_block'
 
 require 'rr/double_definitions/double_definition_create_blank_slate'
 require 'rr/double_definitions/double_definition_create'
@@ -85,27 +87,22 @@ require 'rr/times_called_matchers/at_most_matcher'
 require 'rr/spy_verification_proxy'
 require 'rr/spy_verification'
 
-require 'rr/adapters'
 require 'rr/integrations'
 require 'rr/integrations/decorator'
 require 'rr/integrations/rspec/invocation_matcher'
-require 'rr/integrations/rspec_1'
 require 'rr/integrations/rspec_2'
 require 'rr/integrations/minitest_4'
 require 'rr/integrations/minitest_4_active_support'
 require 'rr/integrations/minitest'
 require 'rr/integrations/minitest_active_support'
-require 'rr/integrations/test_unit_1'
-require 'rr/integrations/test_unit_200'
-require 'rr/integrations/test_unit_200_active_support'
-require 'rr/integrations/test_unit_2'
-require 'rr/integrations/test_unit_2_active_support'
+
+require 'rr/deprecations'
 
 require 'rr/version'
 
 module RR
   class << self
-    include Adapters::RRMethods
+    include DSL
 
     (RR::Space.instance_methods - Object.instance_methods).each do |method_name|
       class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
@@ -117,10 +114,6 @@ module RR
 
     attr_accessor :debug
     alias_method :debug?, :debug
-
-    def ruby_18?
-      RUBY_VERSION =~ /^1\.8/
-    end
   end
 end
 

data/rr.gemspec

@@ -6,23 +6,32 @@ require File.expand_path('../lib/rr/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.name = 'rr'
   gem.version = RR.version
-  gem.authors = ['Brian Takita', 'Elliot Winkler']
-  gem.email = ['elliot.winkler@gmail.com']
+  gem.authors = ['Kouhei Sutou', 'Brian Takita', 'Elliot Winkler']
+  gem.email = ['kou@cozmixng.org']
   gem.description = 'RR is a test double framework that features a rich selection of double techniques and a terse syntax.'
   gem.summary = 'RR is a test double framework that features a rich selection of double techniques and a terse syntax.'
-  gem.homepage = 'http://rr.github.com/rr'
+  gem.homepage = 'https://rr.github.io/rr'
   gem.license = 'MIT'
 
   gem.files = FileList[
+    'Appraisals',
     'CHANGES.md',
     'CREDITS.md',
+    'Gemfile',
     'LICENSE',
     'README.md',
-    'VERSION',
+    'Rakefile',
     'doc/*.md',
+    'gemfiles/**/*',
     'lib/**/*.rb',
-    'rr.gemspec'
+    'rr.gemspec',
+    'spec/**/*'
   ].to_a
 
   gem.require_paths = ['lib']
+
+  gem.add_development_dependency("bundler")
+  gem.add_development_dependency("rake")
+  gem.add_development_dependency("test-unit")
+  gem.add_development_dependency("test-unit-rr")
 end

data/spec/custom_formatter_for_rspec.rb

@@ -0,0 +1,18 @@
+require 'spec/runner/formatter/specdoc_formatter'
+
+class CustomFormatterForRSpec < Spec::Runner::Formatter::SpecdocFormatter
+  def example_passed(example)
+    super
+    output.flush
+  end
+
+  def example_pending(example, message)
+    super
+    output.flush
+  end
+
+  def example_failed(example, counter, failure)
+    super
+    output.flush
+  end
+end

data/spec/custom_formatter_for_rspec_2.rb

@@ -0,0 +1,40 @@
+require 'rspec/core/formatters/base_text_formatter'
+
+class CustomFormatterForRSpec2 < RSpec::Core::Formatters::BaseTextFormatter
+  def example_passed(example)
+    super(example)
+    output.puts passed_output(example)
+    output.flush
+  end
+
+  def example_pending(example)
+    super(example)
+    output.puts pending_output(example, example.execution_result[:pending_message])
+    output.flush
+  end
+
+  def example_failed(example)
+    super(example)
+    output.puts failure_output(example, example.execution_result[:exception])
+    output.flush
+  end
+
+  private
+
+  def passed_output(example)
+    success_color("#{example.full_description.strip}")
+  end
+
+  def pending_output(example, message)
+    pending_color("#{example.full_description.strip} (PENDING: #{message})")
+  end
+
+  def failure_output(example, exception)
+    failure_color("#{example.full_description.strip} (FAILED - #{next_failure_index})")
+  end
+
+  def next_failure_index
+    @next_failure_index ||= 0
+    @next_failure_index += 1
+  end
+end

data/spec/defines_spec_suite_tasks.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../spec_suite_configuration', __FILE__)
+
+require 'ostruct'
+
+class DefinesSpecSuiteTasks
+  extend Rake::DSL
+
+  def self.configuration
+    @configuration ||= SpecSuiteConfiguration.build
+  end
+
+  def self.call
+    desc 'Run all tests'
+    task :spec do
+      results = []
+      DefinesSpecSuiteTasks.configuration.each_matching_suite.each do |suite|
+        puts "=== Running #{suite.desc} tests ================================================"
+        results << suite.run
+        puts
+      end
+      if results.any? { |result| not result.success? }
+        raise 'Spec suite failed!'
+      end
+    end
+
+    namespace :spec do
+      DefinesSpecSuiteTasks.configuration.each_matching_suite do |suite|
+        desc "Run #{suite.desc} tests"
+        task suite.name => "appraisal:#{suite.appraisal_name}:install" do
+          result = suite.run
+          if not result.success?
+            raise "#{suite.desc} suite failed!"
+          end
+        end
+      end
+
+      require 'rspec/core/rake_task'
+
+      desc "Run the unit tests"
+      RSpec::Core::RakeTask.new(:unit) do |t|
+        t.pattern = 'spec/suites/rspec_2/unit/**/*_spec.rb'
+      end
+
+      desc "Run the functional (API) tests"
+      RSpec::Core::RakeTask.new(:functional) do |t|
+        t.pattern = 'spec/suites/rspec_2/functional/**/*_spec.rb'
+      end
+    end
+
+    namespace :travis do
+      desc 'Regenerate .travis.yml'
+      task :regenerate_config do
+        DefinesSpecSuiteTasks.configuration.generate_travis_config
+      end
+    end
+  end
+end

data/spec/fixtures/rubygems_patch_for_187.rb

@@ -0,0 +1,598 @@
+require 'rails/gem_dependency'
+
+module Gem
+  ## Copied from RubyGems 1.3.7 (Ruby 1.9.2)
+  class SourceIndex
+    include Enumerable
+
+    attr_reader :gems # :nodoc:
+
+    ##
+    # Directories to use to refresh this SourceIndex when calling refresh!
+
+    attr_accessor :spec_dirs
+
+    class << self
+      ##
+      # Factory method to construct a source index instance for a given
+      # path.
+      #
+      # deprecated::
+      #   If supplied, from_installed_gems will act just like
+      #   +from_gems_in+.  This argument is deprecated and is provided
+      #   just for backwards compatibility, and should not generally
+      #   be used.
+      #
+      # return::
+      #   SourceIndex instance
+
+      def from_installed_gems(*deprecated)
+        if deprecated.empty?
+          from_gems_in(*installed_spec_directories)
+        else
+          from_gems_in(*deprecated) # HACK warn
+        end
+      end
+
+      ##
+      # Returns a list of directories from Gem.path that contain specifications.
+
+      def installed_spec_directories
+        Gem.path.collect { |dir| File.join(dir, "specifications") }
+      end
+
+      ##
+      # Creates a new SourceIndex from the ruby format gem specifications in
+      # +spec_dirs+.
+
+      def from_gems_in(*spec_dirs)
+        source_index = new
+        source_index.spec_dirs = spec_dirs
+        source_index.refresh!
+      end
+
+      ##
+      # Loads a ruby-format specification from +file_name+ and returns the
+      # loaded spec.
+
+      def load_specification(file_name)
+        return nil unless file_name and File.exist? file_name
+
+        spec_code = if defined? Encoding then
+                      File.read file_name, :encoding => 'UTF-8'
+                    else
+                      File.read file_name
+                    end.untaint
+
+        begin
+          gemspec = eval spec_code, binding, file_name
+
+          if gemspec.is_a?(Gem::Specification)
+            gemspec.loaded_from = file_name
+            return gemspec
+          end
+          alert_warning "File '#{file_name}' does not evaluate to a gem specification"
+        rescue SignalException, SystemExit
+          raise
+        rescue SyntaxError => e
+          alert_warning e
+          alert_warning spec_code
+        rescue Exception => e
+          alert_warning "#{e.inspect}\n#{spec_code}"
+          alert_warning "Invalid .gemspec format in '#{file_name}'"
+        end
+
+        return nil
+      end
+
+    end
+
+    ##
+    # Constructs a source index instance from the provided specifications, which
+    # is a Hash of gem full names and Gem::Specifications.
+    #--
+    # TODO merge @gems and @prerelease_gems and provide a separate method
+    # #prerelease_gems
+
+    def initialize(specifications={})
+      @gems = {}
+      specifications.each{ |full_name, spec| add_spec spec }
+      @spec_dirs = nil
+    end
+
+    # TODO: remove method
+    def all_gems
+      @gems
+    end
+
+    def prerelease_gems
+      @gems.reject{ |name, gem| !gem.version.prerelease? }
+    end
+
+    def released_gems
+      @gems.reject{ |name, gem| gem.version.prerelease? }
+    end
+
+    ##
+    # Reconstruct the source index from the specifications in +spec_dirs+.
+
+    def load_gems_in(*spec_dirs)
+      @gems.clear
+
+      spec_dirs.reverse_each do |spec_dir|
+        spec_files = Dir.glob File.join(spec_dir, '*.gemspec')
+
+        spec_files.each do |spec_file|
+          gemspec = self.class.load_specification spec_file.untaint
+          add_spec gemspec if gemspec
+        end
+      end
+
+      self
+    end
+
+    ##
+    # Returns an Array specifications for the latest released versions
+    # of each gem in this index.
+
+    def latest_specs
+      result = Hash.new { |h,k| h[k] = [] }
+      latest = {}
+
+      sort.each do |_, spec|
+        name = spec.name
+        curr_ver = spec.version
+        prev_ver = latest.key?(name) ? latest[name].version : nil
+
+        next if curr_ver.prerelease?
+        next unless prev_ver.nil? or curr_ver >= prev_ver or
+                    latest[name].platform != Gem::Platform::RUBY
+
+        if prev_ver.nil? or
+           (curr_ver > prev_ver and spec.platform == Gem::Platform::RUBY) then
+          result[name].clear
+          latest[name] = spec
+        end
+
+        if spec.platform != Gem::Platform::RUBY then
+          result[name].delete_if do |result_spec|
+            result_spec.platform == spec.platform
+          end
+        end
+
+        result[name] << spec
+      end
+
+      # TODO: why is this a hash while @gems is an array? Seems like
+      # structural similarity would be good.
+      result.values.flatten
+    end
+
+    ##
+    # An array including only the prerelease gemspecs
+
+    def prerelease_specs
+      prerelease_gems.values
+    end
+
+    ##
+    # An array including only the released gemspecs
+
+    def released_specs
+      released_gems.values
+    end
+
+    ##
+    # Add a gem specification to the source index.
+
+    def add_spec(gem_spec, name = gem_spec.full_name)
+      # No idea why, but the Indexer wants to insert them using original_name
+      # instead of full_name. So we make it an optional arg.
+      @gems[name] = gem_spec
+    end
+
+    ##
+    # Add gem specifications to the source index.
+
+    def add_specs(*gem_specs)
+      gem_specs.each do |spec|
+        add_spec spec
+      end
+    end
+
+    ##
+    # Remove a gem specification named +full_name+.
+
+    def remove_spec(full_name)
+      @gems.delete full_name
+    end
+
+    ##
+    # Iterate over the specifications in the source index.
+
+    def each(&block) # :yields: gem.full_name, gem
+      @gems.each(&block)
+    end
+
+    ##
+    # The gem specification given a full gem spec name.
+
+    def specification(full_name)
+      @gems[full_name]
+    end
+
+    ##
+    # The signature for the source index.  Changes in the signature indicate a
+    # change in the index.
+
+    def index_signature
+      require 'digest'
+
+      Digest::SHA256.new.hexdigest(@gems.keys.sort.join(',')).to_s
+    end
+
+    ##
+    # The signature for the given gem specification.
+
+    def gem_signature(gem_full_name)
+      require 'digest'
+
+      Digest::SHA256.new.hexdigest(@gems[gem_full_name].to_yaml).to_s
+    end
+
+    def size
+      @gems.size
+    end
+    alias length size
+
+    ##
+    # Find a gem by an exact match on the short name.
+
+    def find_name(gem_name, version_requirement = Gem::Requirement.default)
+      dep = Gem::Dependency.new gem_name, version_requirement
+      search dep
+    end
+
+    ##
+    # Search for a gem by Gem::Dependency +gem_pattern+.  If +only_platform+
+    # is true, only gems matching Gem::Platform.local will be returned.  An
+    # Array of matching Gem::Specification objects is returned.
+    #
+    # For backwards compatibility, a String or Regexp pattern may be passed as
+    # +gem_pattern+, and a Gem::Requirement for +platform_only+.  This
+    # behavior is deprecated and will be removed.
+
+    def search(gem_pattern, platform_only = false)
+      version_requirement = nil
+      only_platform = false
+
+      # TODO - Remove support and warning for legacy arguments after 2008/11
+      unless Gem::Dependency === gem_pattern
+        warn "#{Gem.location_of_caller.join ':'}:Warning: Gem::SourceIndex#search support for #{gem_pattern.class} patterns is deprecated, use #find_name"
+      end
+
+      case gem_pattern
+      when Regexp then
+        version_requirement = platform_only || Gem::Requirement.default
+      when Gem::Dependency then
+        only_platform = platform_only
+        version_requirement = gem_pattern.requirement
+        gem_pattern = if Regexp === gem_pattern.name then
+                        gem_pattern.name
+                      elsif gem_pattern.name.empty? then
+                        //
+                      else
+                        /^#{Regexp.escape gem_pattern.name}$/
+                      end
+      else
+        version_requirement = platform_only || Gem::Requirement.default
+        gem_pattern = /#{gem_pattern}/i
+      end
+
+      unless Gem::Requirement === version_requirement then
+        version_requirement = Gem::Requirement.create version_requirement
+      end
+
+      specs = all_gems.values.select do |spec|
+        spec.name =~ gem_pattern and
+          version_requirement.satisfied_by? spec.version
+      end
+
+      if only_platform then
+        specs = specs.select do |spec|
+          Gem::Platform.match spec.platform
+        end
+      end
+
+      specs.sort_by { |s| s.sort_obj }
+    end
+
+    ##
+    # Replaces the gems in the source index from specifications in the
+    # directories this source index was created from.  Raises an exception if
+    # this source index wasn't created from a directory (via from_gems_in or
+    # from_installed_gems, or having spec_dirs set).
+
+    def refresh!
+      raise 'source index not created from disk' if @spec_dirs.nil?
+      load_gems_in(*@spec_dirs)
+    end
+
+    ##
+    # Returns an Array of Gem::Specifications that are not up to date.
+
+    def outdated
+      outdateds = []
+
+      latest_specs.each do |local|
+        dependency = Gem::Dependency.new local.name, ">= #{local.version}"
+
+        begin
+          fetcher = Gem::SpecFetcher.fetcher
+          remotes = fetcher.find_matching dependency
+          remotes = remotes.map { |(name, version,_),_| version }
+        rescue Gem::RemoteFetcher::FetchError => e
+          raise unless fetcher.warn_legacy e do
+            require 'rubygems/source_info_cache'
+
+            specs = Gem::SourceInfoCache.search_with_source dependency, true
+
+            remotes = specs.map { |spec,| spec.version }
+          end
+        end
+
+        latest = remotes.sort.last
+
+        outdateds << local.name if latest and local.version < latest
+      end
+
+      outdateds
+    end
+
+    ##
+    # Updates this SourceIndex from +source_uri+.  If +all+ is false, only the
+    # latest gems are fetched.
+
+    def update(source_uri, all)
+      source_uri = URI.parse source_uri unless URI::Generic === source_uri
+      source_uri.path += '/' unless source_uri.path =~ /\/$/
+
+      use_incremental = false
+
+      begin
+        gem_names = fetch_quick_index source_uri, all
+        remove_extra gem_names
+        missing_gems = find_missing gem_names
+
+        return false if missing_gems.size.zero?
+
+        say "Missing metadata for #{missing_gems.size} gems" if
+        missing_gems.size > 0 and Gem.configuration.really_verbose
+
+        use_incremental = missing_gems.size <= Gem.configuration.bulk_threshold
+      rescue Gem::OperationNotSupportedError => ex
+        alert_error "Falling back to bulk fetch: #{ex.message}" if
+        Gem.configuration.really_verbose
+        use_incremental = false
+      end
+
+      if use_incremental then
+        update_with_missing(source_uri, missing_gems)
+      else
+        new_index = fetch_bulk_index(source_uri)
+        @gems.replace(new_index.gems)
+      end
+
+      true
+    end
+
+    def ==(other) # :nodoc:
+      self.class === other and @gems == other.gems
+    end
+
+    def dump
+      Marshal.dump(self)
+    end
+
+    private
+
+    def fetcher
+      require 'rubygems/remote_fetcher'
+
+      Gem::RemoteFetcher.fetcher
+    end
+
+    def fetch_index_from(source_uri)
+      @fetch_error = nil
+
+      indexes = %W[
+          Marshal.#{Gem.marshal_version}.Z
+          Marshal.#{Gem.marshal_version}
+          yaml.Z
+          yaml
+        ]
+
+      indexes.each do |name|
+        spec_data = nil
+        index = source_uri + name
+        begin
+          spec_data = fetcher.fetch_path index
+          spec_data = unzip(spec_data) if name =~ /\.Z$/
+
+          if name =~ /Marshal/ then
+            return Marshal.load(spec_data)
+          else
+            return YAML.load(spec_data)
+          end
+        rescue => e
+          if Gem.configuration.really_verbose then
+            alert_error "Unable to fetch #{name}: #{e.message}"
+          end
+
+          @fetch_error = e
+        end
+      end
+
+      nil
+    end
+
+    def fetch_bulk_index(source_uri)
+      say "Bulk updating Gem source index for: #{source_uri}" if
+        Gem.configuration.verbose
+
+      index = fetch_index_from(source_uri)
+      if index.nil? then
+        raise Gem::RemoteSourceException,
+                "Error fetching remote gem cache: #{@fetch_error}"
+      end
+      @fetch_error = nil
+      index
+    end
+
+    ##
+    # Get the quick index needed for incremental updates.
+
+    def fetch_quick_index(source_uri, all)
+      index = all ? 'index' : 'latest_index'
+
+      zipped_index = fetcher.fetch_path source_uri + "quick/#{index}.rz"
+
+      unzip(zipped_index).split("\n")
+    rescue ::Exception => e
+      unless all then
+        say "Latest index not found, using quick index" if
+          Gem.configuration.really_verbose
+
+        fetch_quick_index source_uri, true
+      else
+        raise Gem::OperationNotSupportedError,
+              "No quick index found: #{e.message}"
+      end
+    end
+
+    ##
+    # Make a list of full names for all the missing gemspecs.
+
+    def find_missing(spec_names)
+      unless defined? @originals then
+        @originals = {}
+        each do |full_name, spec|
+          @originals[spec.original_name] = spec
+        end
+      end
+
+      spec_names.find_all { |full_name|
+        @originals[full_name].nil?
+      }
+    end
+
+    def remove_extra(spec_names)
+      dictionary = spec_names.inject({}) { |h, k| h[k] = true; h }
+      each do |name, spec|
+        remove_spec name unless dictionary.include? spec.original_name
+      end
+    end
+
+    ##
+    # Unzip the given string.
+
+    def unzip(string)
+      require 'zlib'
+      Gem.inflate string
+    end
+
+    ##
+    # Tries to fetch Marshal representation first, then YAML
+
+    def fetch_single_spec(source_uri, spec_name)
+      @fetch_error = nil
+
+      begin
+        marshal_uri = source_uri + "quick/Marshal.#{Gem.marshal_version}/#{spec_name}.gemspec.rz"
+        zipped = fetcher.fetch_path marshal_uri
+        return Marshal.load(unzip(zipped))
+      rescue => ex
+        @fetch_error = ex
+
+        if Gem.configuration.really_verbose then
+          say "unable to fetch marshal gemspec #{marshal_uri}: #{ex.class} - #{ex}"
+        end
+      end
+
+      begin
+        yaml_uri = source_uri + "quick/#{spec_name}.gemspec.rz"
+        zipped = fetcher.fetch_path yaml_uri
+        return YAML.load(unzip(zipped))
+      rescue => ex
+        @fetch_error = ex
+        if Gem.configuration.really_verbose then
+          say "unable to fetch YAML gemspec #{yaml_uri}: #{ex.class} - #{ex}"
+        end
+      end
+
+      nil
+    end
+
+    ##
+    # Update the cached source index with the missing names.
+
+    def update_with_missing(source_uri, missing_names)
+      progress = ui.progress_reporter(missing_names.size,
+          "Updating metadata for #{missing_names.size} gems from #{source_uri}")
+      missing_names.each do |spec_name|
+        gemspec = fetch_single_spec(source_uri, spec_name)
+        if gemspec.nil? then
+          ui.say "Failed to download spec #{spec_name} from #{source_uri}:\n" \
+                   "\t#{@fetch_error.message}"
+        else
+          add_spec gemspec
+          progress.updated spec_name
+        end
+        @fetch_error = nil
+      end
+      progress.done
+      progress.count
+    end
+  end
+
+  class FakeSourceIndex
+    include Enumerable
+
+    def initialize(specs_by_filename = {})
+      @specs_by_filename = specs_by_filename
+    end
+
+    def search(dep)
+      Specification.find_all_by_name(dep.name, dep.requirement)
+    end
+
+    def each
+      Specification.each do |spec|
+        yield spec.name, spec
+      end
+    end
+  end
+
+  class Specification
+    alias_method :installation_path, :base_dir
+  end
+
+  class << self
+    attr_accessor :source_index
+    alias_method :cache, :source_index
+
+    ## Copied from RubyGems 1.3.7 (Ruby 1.9.2)
+    def available?(gem, *requirements)
+      requirements = Gem::Requirement.default if requirements.empty?
+
+      unless gem.respond_to?(:name) and
+             gem.respond_to?(:requirement) then
+        gem = Gem::Dependency.new gem, requirements
+      end
+
+      !Gem.source_index.search(gem).empty?
+    end
+  end
+
+  self.source_index = FakeSourceIndex.new
+end