depengine 0.0.31 → 3.0.0

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/secure_random.rb

@@ -1,199 +0,0 @@
-begin
-  require 'securerandom'
-rescue LoadError
-end
-
-module ActiveSupport
-  if defined?(::SecureRandom)
-    # Use Ruby's SecureRandom library if available.
-    SecureRandom = ::SecureRandom # :nodoc:
-  else
-    # = Secure random number generator interface.
-    #
-    # This library is an interface for secure random number generator which is
-    # suitable for generating session key in HTTP cookies, etc.
-    #
-    # It supports following secure random number generators.
-    #
-    # * openssl
-    # * /dev/urandom
-    # * Win32
-    #
-    # *Note*: This module is based on the SecureRandom library from Ruby 1.9,
-    # revision 18786, August 23 2008. It's 100% interface-compatible with Ruby 1.9's
-    # SecureRandom library.
-    #
-    # == Example
-    #
-    #  # random hexadecimal string.
-    #  p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
-    #  p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
-    #  p SecureRandom.hex(11) #=> "6aca1b5c58e4863e6b81b8"
-    #  p SecureRandom.hex(12) #=> "94b2fff3e7fd9b9c391a2306"
-    #  p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
-    #  ...
-    #
-    #  # random base64 string.
-    #  p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
-    #  p SecureRandom.base64(10) #=> "9b0nsevdwNuM/w=="
-    #  p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
-    #  p SecureRandom.base64(11) #=> "l7XEiFja+8EKEtY="
-    #  p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
-    #  p SecureRandom.base64(13) #=> "vKLJ0tXBHqQOuIcSIg=="
-    #  ...
-    #
-    #  # random binary string.
-    #  p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
-    #  p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
-    #  ...
-    module SecureRandom
-      # SecureRandom.random_bytes generates a random binary string.
-      #
-      # The argument n specifies the length of the result string.
-      #
-      # If n is not specified, 16 is assumed.
-      # It may be larger in future.
-      #
-      # If secure random number generator is not available,
-      # NotImplementedError is raised.
-      def self.random_bytes(n=nil)
-        n ||= 16
-
-        unless defined? OpenSSL
-          begin
-            require 'openssl'
-          rescue LoadError
-          end
-        end
-
-        if defined? OpenSSL::Random
-          return OpenSSL::Random.random_bytes(n)
-        end
-
-        if !defined?(@has_urandom) || @has_urandom
-          flags = File::RDONLY
-          flags |= File::NONBLOCK if defined? File::NONBLOCK
-          flags |= File::NOCTTY if defined? File::NOCTTY
-          flags |= File::NOFOLLOW if defined? File::NOFOLLOW
-          begin
-            File.open("/dev/urandom", flags) {|f|
-              unless f.stat.chardev?
-                raise Errno::ENOENT
-              end
-              @has_urandom = true
-              ret = f.readpartial(n)
-              if ret.length != n
-                raise NotImplementedError, "Unexpected partial read from random device"
-              end
-              return ret
-            }
-          rescue Errno::ENOENT
-            @has_urandom = false
-          end
-        end
-
-        if !defined?(@has_win32)
-          begin
-            require 'Win32API'
-
-            crypt_acquire_context = Win32API.new("advapi32", "CryptAcquireContext", 'PPPII', 'L')
-            @crypt_gen_random = Win32API.new("advapi32", "CryptGenRandom", 'LIP', 'L')
-
-            hProvStr = " " * 4
-            prov_rsa_full = 1
-            crypt_verifycontext = 0xF0000000
-
-            if crypt_acquire_context.call(hProvStr, nil, nil, prov_rsa_full, crypt_verifycontext) == 0
-              raise SystemCallError, "CryptAcquireContext failed: #{lastWin32ErrorMessage}"
-            end
-            @hProv, = hProvStr.unpack('L')
-
-            @has_win32 = true
-          rescue LoadError
-            @has_win32 = false
-          end
-        end
-        if @has_win32
-          bytes = " " * n
-          if @crypt_gen_random.call(@hProv, bytes.size, bytes) == 0
-            raise SystemCallError, "CryptGenRandom failed: #{lastWin32ErrorMessage}"
-          end
-          return bytes
-        end
-
-        raise NotImplementedError, "No random device"
-      end
-
-      # SecureRandom.hex generates a random hex string.
-      #
-      # The argument n specifies the length of the random length.
-      # The length of the result string is twice of n.
-      #
-      # If n is not specified, 16 is assumed.
-      # It may be larger in future.
-      #
-      # If secure random number generator is not available,
-      # NotImplementedError is raised.
-      def self.hex(n=nil)
-        random_bytes(n).unpack("H*")[0]
-      end
-
-      # SecureRandom.base64 generates a random base64 string.
-      #
-      # The argument n specifies the length of the random length.
-      # The length of the result string is about 4/3 of n.
-      #
-      # If n is not specified, 16 is assumed.
-      # It may be larger in future.
-      #
-      # If secure random number generator is not available,
-      # NotImplementedError is raised.
-      def self.base64(n=nil)
-        [random_bytes(n)].pack("m*").delete("\n")
-      end
-
-      # SecureRandom.random_number generates a random number.
-      #
-      # If an positive integer is given as n,
-      # SecureRandom.random_number returns an integer:
-      # 0 <= SecureRandom.random_number(n) < n.
-      #
-      # If 0 is given or an argument is not given,
-      # SecureRandom.random_number returns an float:
-      # 0.0 <= SecureRandom.random_number() < 1.0.
-      def self.random_number(n=0)
-        if 0 < n
-          hex = n.to_s(16)
-          hex = '0' + hex if (hex.length & 1) == 1
-          bin = [hex].pack("H*")
-          mask = bin[0]
-          mask |= mask >> 1
-          mask |= mask >> 2
-          mask |= mask >> 4
-          begin
-            rnd = SecureRandom.random_bytes(bin.length)
-            rnd[0] = rnd[0] & mask
-          end until rnd < bin
-          rnd.unpack("H*")[0].hex
-        else
-          # assumption: Float::MANT_DIG <= 64
-          i64 = SecureRandom.random_bytes(8).unpack("Q")[0]
-          Math.ldexp(i64 >> (64-Float::MANT_DIG), -Float::MANT_DIG)
-        end
-      end
-
-      # Following code is based on David Garamond's GUID library for Ruby.
-      def self.lastWin32ErrorMessage # :nodoc:
-        get_last_error = Win32API.new("kernel32", "GetLastError", '', 'L')
-        format_message = Win32API.new("kernel32", "FormatMessageA", 'LPLLPLPPPPPPPP', 'L')
-        format_message_ignore_inserts = 0x00000200
-        format_message_from_system    = 0x00001000
-
-        code = get_last_error.call
-        msg = "\0" * 1024
-        len = format_message.call(format_message_ignore_inserts + format_message_from_system, 0, code, 0, msg, 1024, nil, nil, nil, nil, nil, nil, nil, nil)
-        msg[0, len].tr("\r", '').chomp
-      end
-    end
-  end
-end

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/string_inquirer.rb

@@ -1,21 +0,0 @@
-module ActiveSupport
-  # Wrapping a string in this class gives you a prettier way to test
-  # for equality. The value returned by <tt>Rails.env</tt> is wrapped
-  # in a StringInquirer object so instead of calling this:
-  #
-  #   Rails.env == "production"
-  #
-  # you can call this:
-  #
-  #   Rails.env.production?
-  #
-  class StringInquirer < String
-    def method_missing(method_name, *arguments)
-      if method_name.to_s[-1,1] == "?"
-        self == method_name.to_s[0..-2]
-      else
-        super
-      end
-    end
-  end
-end

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/test_case.rb

@@ -1,40 +0,0 @@
-require 'test/unit/testcase'
-require 'active_support/testing/setup_and_teardown'
-require 'active_support/testing/assertions'
-require 'active_support/testing/deprecation'
-require 'active_support/testing/declarative'
-
-begin
-  gem 'mocha', ">= 0.9.7"
-  require 'mocha'
-rescue LoadError
-  # Fake Mocha::ExpectationError so we can rescue it in #run. Bleh.
-  Object.const_set :Mocha, Module.new
-  Mocha.const_set :ExpectationError, Class.new(StandardError)
-end
-
-module ActiveSupport
-  class TestCase < ::Test::Unit::TestCase
-    if defined? MiniTest
-      Assertion = MiniTest::Assertion
-      alias_method :method_name, :name if method_defined? :name
-      alias_method :method_name, :__name__ if method_defined? :__name__
-    else
-      # TODO: Figure out how to get the Rails::BacktraceFilter into minitest/unit
-      if defined?(Rails) && ENV['BACKTRACE'].nil?
-        require 'rails/backtrace_cleaner'
-        Test::Unit::Util::BacktraceFilter.module_eval { include Rails::BacktraceFilterForTestUnit }
-      end
-
-      Assertion = Test::Unit::AssertionFailedError
-
-      require 'active_support/testing/default'
-      include ActiveSupport::Testing::Default
-    end
-
-    include ActiveSupport::Testing::SetupAndTeardown
-    include ActiveSupport::Testing::Assertions
-    include ActiveSupport::Testing::Deprecation
-    extend ActiveSupport::Testing::Declarative
-  end
-end

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/testing/assertions.rb

@@ -1,79 +0,0 @@
-module ActiveSupport
-  module Testing
-    module Assertions
-      # Test numeric difference between the return value of an expression as a result of what is evaluated
-      # in the yielded block.
-      #
-      #   assert_difference 'Article.count' do
-      #     post :create, :article => {...}
-      #   end
-      #
-      # An arbitrary expression is passed in and evaluated.
-      #
-      #   assert_difference 'assigns(:article).comments(:reload).size' do
-      #     post :create, :comment => {...}
-      #   end
-      #
-      # An arbitrary positive or negative difference can be specified. The default is +1.
-      #
-      #   assert_difference 'Article.count', -1 do
-      #     post :delete, :id => ...
-      #   end
-      #
-      # An array of expressions can also be passed in and evaluated.
-      #
-      #   assert_difference [ 'Article.count', 'Post.count' ], +2 do
-      #     post :create, :article => {...}
-      #   end
-      #
-      # A error message can be specified.
-      #
-      #   assert_difference 'Article.count', -1, "An Article should be destroyed" do
-      #     post :delete, :id => ...
-      #   end
-      def assert_difference(expression, difference = 1, message = nil, &block)
-        b = block.send(:binding)
-        exps = Array.wrap(expression)
-        before = exps.map { |e| eval(e, b) }
-
-        yield
-
-        exps.each_with_index do |e, i|
-          error = "#{e.inspect} didn't change by #{difference}"
-          error = "#{message}.\n#{error}" if message
-          assert_equal(before[i] + difference, eval(e, b), error)
-        end
-      end
-
-      # Assertion that the numeric result of evaluating an expression is not changed before and after
-      # invoking the passed in block.
-      #
-      #   assert_no_difference 'Article.count' do
-      #     post :create, :article => invalid_attributes
-      #   end
-      #
-      # A error message can be specified.
-      #
-      #   assert_no_difference 'Article.count', "An Article should not be destroyed" do
-      #     post :create, :article => invalid_attributes
-      #   end
-      def assert_no_difference(expression, message = nil, &block)
-        assert_difference expression, 0, message, &block
-      end
-      
-      # Test if an expression is blank. Passes if object.blank? is true.
-      #
-      #   assert_blank [] # => true
-      def assert_blank(object)
-        assert object.blank?, "#{object.inspect} is not blank"
-      end
-      
-      # Test if an expression is not blank. Passes if object.present? is true.
-      #
-      #   assert_present {:data => 'x' } # => true
-      def assert_present(object)
-        assert object.present?, "#{object.inspect} is blank"
-      end
-    end
-  end
-end

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/testing/declarative.rb

@@ -1,21 +0,0 @@
-module ActiveSupport
-  module Testing
-    module Declarative
-      # test "verify something" do
-      #   ...
-      # end
-      def test(name, &block)
-        test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
-        defined = instance_method(test_name) rescue false
-        raise "#{test_name} is already defined in #{self}" if defined
-        if block_given?
-          define_method(test_name, &block)
-        else
-          define_method(test_name) do
-            flunk "No implementation provided for #{name}"
-          end
-        end
-      end
-    end
-  end
-end

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/testing/default.rb

@@ -1,9 +0,0 @@
-module ActiveSupport
-  module Testing
-    module Default #:nodoc:
-      # Placeholder so test/unit ignores test cases without any tests.
-      def default_test
-      end
-    end
-  end
-end

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/testing/deprecation.rb

@@ -1,57 +0,0 @@
-require "active_support/core_ext/module"
-
-module ActiveSupport
-  module Testing
-    module Deprecation #:nodoc:
-      def assert_deprecated(match = nil, &block)
-        result, warnings = collect_deprecations(&block)
-        assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
-        if match
-          match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
-          assert warnings.any? { |w| w =~ match }, "No deprecation warning matched #{match}: #{warnings.join(', ')}"
-        end
-        result
-      end
-
-      def assert_not_deprecated(&block)
-        result, deprecations = collect_deprecations(&block)
-        assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
-        result
-      end
-
-      private
-        def collect_deprecations
-          old_behavior = ActiveSupport::Deprecation.behavior
-          deprecations = []
-          ActiveSupport::Deprecation.behavior = Proc.new do |message, callstack|
-            deprecations << message
-          end
-          result = yield
-          [result, deprecations]
-        ensure
-          ActiveSupport::Deprecation.behavior = old_behavior
-        end
-    end
-  end
-end
-
-begin
-  require 'test/unit/error'
-
-  module Test
-    module Unit
-      class Error # :nodoc:
-        # Silence warnings when reporting test errors.
-        def message_with_silenced_deprecation
-          ActiveSupport::Deprecation.silence do
-            message_without_silenced_deprecation
-          end
-        end
-
-        alias_method_chain :message, :silenced_deprecation
-      end
-    end
-  end
-rescue LoadError
-  # Using miniunit, ignore.
-end

data/etc/isolate/jruby-1.8/gems/activesupport-2.3.8/lib/active_support/testing/performance.rb

@@ -1,452 +0,0 @@
-require 'rubygems'
-gem 'ruby-prof', '>= 0.6.1'
-require 'ruby-prof'
-
-require 'fileutils'
-require 'rails/version'
-
-module ActiveSupport
-  module Testing
-    module Performance
-      DEFAULTS =
-        if benchmark = ARGV.include?('--benchmark')  # HAX for rake test
-          { :benchmark => true,
-            :runs => 4,
-            :metrics => [:wall_time, :memory, :objects, :gc_runs, :gc_time],
-            :output => 'tmp/performance' }
-        else
-          { :benchmark => false,
-            :runs => 1,
-            :min_percent => 0.01,
-            :metrics => [:process_time, :memory, :objects],
-            :formats => [:flat, :graph_html, :call_tree],
-            :output => 'tmp/performance' }
-        end.freeze
-
-      def self.included(base)
-        base.superclass_delegating_accessor :profile_options
-        base.profile_options = DEFAULTS
-      end
-
-      def full_test_name
-        "#{self.class.name}##{method_name}"
-      end
-
-      def run(result)
-        return if method_name =~ /^default_test$/
-
-        yield(self.class::STARTED, name)
-        @_result = result
-
-        run_warmup
-        if profile_options && metrics = profile_options[:metrics]
-          metrics.each do |metric_name|
-            if klass = Metrics[metric_name.to_sym]
-              run_profile(klass.new)
-              result.add_run
-            end
-          end
-        end
-
-        yield(self.class::FINISHED, name)
-      end
-
-      def run_test(metric, mode)
-        run_callbacks :setup
-        setup
-        metric.send(mode) { __send__ @method_name }
-      rescue ::Test::Unit::AssertionFailedError => e
-        add_failure(e.message, e.backtrace)
-      rescue StandardError, ScriptError
-        add_error($!)
-      ensure
-        begin
-          teardown
-          run_callbacks :teardown, :enumerator => :reverse_each
-        rescue ::Test::Unit::AssertionFailedError => e
-          add_failure(e.message, e.backtrace)
-        rescue StandardError, ScriptError
-          add_error($!)
-        end
-      end
-
-      protected
-        def run_warmup
-          GC.start
-
-          time = Metrics::Time.new
-          run_test(time, :benchmark)
-          puts "%s (%s warmup)" % [full_test_name, time.format(time.total)]
-
-          GC.start
-        end
-
-        def run_profile(metric)
-          klass = profile_options[:benchmark] ? Benchmarker : Profiler
-          performer = klass.new(self, metric)
-
-          performer.run
-          puts performer.report
-          performer.record
-        end
-
-      class Performer
-        delegate :run_test, :profile_options, :full_test_name, :to => :@harness
-
-        def initialize(harness, metric)
-          @harness, @metric = harness, metric
-        end
-
-        def report
-          rate = @total / profile_options[:runs]
-          '%20s: %s' % [@metric.name, @metric.format(rate)]
-        end
-
-        protected
-          def output_filename
-            "#{profile_options[:output]}/#{full_test_name}_#{@metric.name}"
-          end
-      end
-
-      class Benchmarker < Performer
-        def run
-          profile_options[:runs].to_i.times { run_test(@metric, :benchmark) }
-          @total = @metric.total
-        end
-
-        def record
-          avg = @metric.total / profile_options[:runs].to_i
-          now = Time.now.utc.xmlschema
-          with_output_file do |file|
-            file.puts "#{avg},#{now},#{environment}"
-          end
-        end
-
-        def environment
-          unless defined? @env
-            app = "#{$1}.#{$2}" if File.directory?('.git') && `git branch -v` =~ /^\* (\S+)\s+(\S+)/
-
-            rails = Rails::VERSION::STRING
-            if File.directory?('vendor/rails/.git')
-              Dir.chdir('vendor/rails') do
-                rails += ".#{$1}.#{$2}" if `git branch -v` =~ /^\* (\S+)\s+(\S+)/
-              end
-            end
-
-            ruby = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-            ruby += "-#{RUBY_VERSION}.#{RUBY_PATCHLEVEL}"
-
-            @env = [app, rails, ruby, RUBY_PLATFORM] * ','
-          end
-
-          @env
-        end
-
-        protected
-          HEADER = 'measurement,created_at,app,rails,ruby,platform'
-
-          def with_output_file
-            fname = output_filename
-
-            if new = !File.exist?(fname)
-              FileUtils.mkdir_p(File.dirname(fname))
-            end
-
-            File.open(fname, 'ab') do |file|
-              file.puts(HEADER) if new
-              yield file
-            end
-          end
-
-          def output_filename
-            "#{super}.csv"
-          end
-      end
-
-      class Profiler < Performer
-        def initialize(*args)
-          super
-          @supported = @metric.measure_mode rescue false
-        end
-
-        def run
-          return unless @supported
-
-          RubyProf.measure_mode = @metric.measure_mode
-          RubyProf.start
-          RubyProf.pause
-          profile_options[:runs].to_i.times { run_test(@metric, :profile) }
-          @data = RubyProf.stop
-          @total = @data.threads.values.sum(0) { |method_infos| method_infos.sort.last.total_time }
-        end
-
-        def report
-          if @supported
-            super
-          else
-            '%20s: unsupported' % @metric.name
-          end
-        end
-
-        def record
-          return unless @supported
-
-          klasses = profile_options[:formats].map { |f| RubyProf.const_get("#{f.to_s.camelize}Printer") }.compact
-
-          klasses.each do |klass|
-            fname = output_filename(klass)
-            FileUtils.mkdir_p(File.dirname(fname))
-            File.open(fname, 'wb') do |file|
-              klass.new(@data).print(file, profile_options.slice(:min_percent))
-            end
-          end
-        end
-
-        protected
-          def output_filename(printer_class)
-            suffix =
-              case printer_class.name.demodulize
-                when 'FlatPrinter'; 'flat.txt'
-                when 'GraphPrinter'; 'graph.txt'
-                when 'GraphHtmlPrinter'; 'graph.html'
-                when 'CallTreePrinter'; 'tree.txt'
-                else printer_class.name.sub(/Printer$/, '').underscore
-              end
-
-            "#{super()}_#{suffix}"
-          end
-      end
-
-      module Metrics
-        def self.[](name)
-          const_get(name.to_s.camelize)
-        rescue NameError
-          nil
-        end
-
-        class Base
-          attr_reader :total
-
-          def initialize
-            @total = 0
-          end
-
-          def name
-            @name ||= self.class.name.demodulize.underscore
-          end
-
-          def measure_mode
-            self.class::Mode
-          end
-
-          def measure
-            0
-          end
-
-          def benchmark
-            with_gc_stats do
-              before = measure
-              yield
-              @total += (measure - before)
-            end
-          end
-
-          def profile
-            RubyProf.resume
-            yield
-          ensure
-            RubyProf.pause
-          end
-
-          protected
-            if GC.respond_to?(:enable_stats)
-              def with_gc_stats
-                GC.enable_stats
-                yield
-              ensure
-                GC.disable_stats
-              end
-            elsif defined?(GC::Profiler)
-              def with_gc_stats
-                GC.start
-                GC.disable
-                GC::Profiler.enable
-                yield
-              ensure
-                GC::Profiler.disable
-                GC.enable
-              end
-            else
-              def with_gc_stats
-                yield
-              end
-            end
-        end
-
-        class Time < Base
-          def measure
-            ::Time.now.to_f
-          end
-
-          def format(measurement)
-            if measurement < 2
-              '%d ms' % (measurement * 1000)
-            else
-              '%.2f sec' % measurement
-            end
-          end
-        end
-
-        class ProcessTime < Time
-          Mode = RubyProf::PROCESS_TIME
-
-          def measure
-            RubyProf.measure_process_time
-          end
-        end
-
-        class WallTime < Time
-          Mode = RubyProf::WALL_TIME
-
-          def measure
-            RubyProf.measure_wall_time
-          end
-        end
-
-        class CpuTime < Time
-          Mode = RubyProf::CPU_TIME if RubyProf.const_defined?(:CPU_TIME)
-
-          def initialize(*args)
-            # FIXME: yeah my CPU is 2.33 GHz
-            RubyProf.cpu_frequency = 2.33e9
-            super
-          end
-
-          def measure
-            RubyProf.measure_cpu_time
-          end
-        end
-
-        class Memory < Base
-          Mode = RubyProf::MEMORY if RubyProf.const_defined?(:MEMORY)
-
-          # ruby-prof wrapper
-          if RubyProf.respond_to?(:measure_memory)
-            def measure
-              RubyProf.measure_memory / 1024.0
-            end
-
-          # Ruby 1.8 + railsbench patch
-          elsif GC.respond_to?(:allocated_size)
-            def measure
-              GC.allocated_size / 1024.0
-            end
-
-          # Ruby 1.8 + lloyd patch
-          elsif GC.respond_to?(:heap_info)
-            def measure
-              GC.heap_info['heap_current_memory'] / 1024.0
-            end
-
-          # Ruby 1.9 with total_malloc_allocated_size patch
-          elsif GC.respond_to?(:malloc_total_allocated_size)
-            def measure
-              GC.total_malloc_allocated_size / 1024.0
-            end
-
-          # Ruby 1.9 unpatched
-          elsif GC.respond_to?(:malloc_allocated_size)
-            def measure
-              GC.malloc_allocated_size / 1024.0
-            end
-
-          # Ruby 1.9 + GC profiler patch
-          elsif defined?(GC::Profiler)
-            def measure
-              GC.enable
-              GC.start
-              kb = GC::Profiler.data.last[:HEAP_USE_SIZE] / 1024.0
-              GC.disable
-              kb
-            end
-          end
-
-          def format(measurement)
-            '%.2f KB' % measurement
-          end
-        end
-
-        class Objects < Base
-          Mode = RubyProf::ALLOCATIONS if RubyProf.const_defined?(:ALLOCATIONS)
-
-          if RubyProf.respond_to?(:measure_allocations)
-            def measure
-              RubyProf.measure_allocations
-            end
-
-          # Ruby 1.8 + railsbench patch
-          elsif ObjectSpace.respond_to?(:allocated_objects)
-            def measure
-              ObjectSpace.allocated_objects
-            end
-
-          # Ruby 1.9 + GC profiler patch
-          elsif defined?(GC::Profiler)
-            def measure
-              GC.enable
-              GC.start
-              last = GC::Profiler.data.last
-              count = last[:HEAP_LIVE_OBJECTS] + last[:HEAP_FREE_OBJECTS]
-              GC.disable
-              count
-            end
-          end
-
-          def format(measurement)
-            measurement.to_i.to_s
-          end
-        end
-
-        class GcRuns < Base
-          Mode = RubyProf::GC_RUNS if RubyProf.const_defined?(:GC_RUNS)
-
-          if RubyProf.respond_to?(:measure_gc_runs)
-            def measure
-              RubyProf.measure_gc_runs
-            end
-          elsif GC.respond_to?(:collections)
-            def measure
-              GC.collections
-            end
-          elsif GC.respond_to?(:heap_info)
-            def measure
-              GC.heap_info['num_gc_passes']
-            end
-          end
-
-          def format(measurement)
-            measurement.to_i.to_s
-          end
-        end
-
-        class GcTime < Base
-          Mode = RubyProf::GC_TIME if RubyProf.const_defined?(:GC_TIME)
-
-          if RubyProf.respond_to?(:measure_gc_time)
-            def measure
-              RubyProf.measure_gc_time
-            end
-          elsif GC.respond_to?(:time)
-            def measure
-              GC.time
-            end
-          end
-
-          def format(measurement)
-            '%d ms' % (measurement / 1000)
-          end
-        end
-      end
-    end
-  end
-end