activesupport 3.1.0.beta1 → 3.1.0.rc1

data/lib/active_support/core_ext/string/behavior.rb

@@ -1,6 +1,5 @@
 class String
-  # Enable more predictable duck-typing on String-like classes. See
-  # Object#acts_like?.
+  # Enable more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
   def acts_like_string?
     true
   end

data/lib/active_support/core_ext/string/exclude.rb

@@ -1,5 +1,5 @@
 class String
-  # The inverse of String#include?. Returns true if the string does not include the other string.
+  # The inverse of <tt>String#include?</tt>. Returns true if the string does not include the other string.
   def exclude?(string)
     !include?(string)
   end

data/lib/active_support/core_ext/string/inquiry.rb

@@ -1,7 +1,7 @@
 require 'active_support/string_inquirer'
 
 class String
-  # Wraps the current string in the ActiveSupport::StringInquirer class,
+  # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,
   # which gives you a prettier way to test for equality. Example:
   #
   #   env = "production".inquiry

data/lib/active_support/core_ext/time/calculations.rb

@@ -1,4 +1,5 @@
 require 'active_support/duration'
+require 'active_support/core_ext/time/zones'
 
 class Time
   COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
@@ -187,7 +188,7 @@ class Time
   # Returns a new Time representing the start of the day (0:00)
   def beginning_of_day
     #(self - seconds_since_midnight).change(:usec => 0)
-    change(:hour => 0, :min => 0, :sec => 0, :usec => 0)
+    change(:hour => 0)
   end
   alias :midnight :beginning_of_day
   alias :at_midnight :beginning_of_day
@@ -201,7 +202,7 @@ class Time
   # Returns a new Time representing the start of the month (1st of the month, 0:00)
   def beginning_of_month
     #self - ((self.mday-1).days + self.seconds_since_midnight)
-    change(:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
+    change(:day => 1, :hour => 0)
   end
   alias :at_beginning_of_month :beginning_of_month
 
@@ -227,7 +228,7 @@ class Time
 
   # Returns  a new Time representing the start of the year (1st of january, 0:00)
   def beginning_of_year
-    change(:month => 1, :day => 1, :hour => 0, :min => 0, :sec => 0, :usec => 0)
+    change(:month => 1, :day => 1, :hour => 0)
   end
   alias :at_beginning_of_year :beginning_of_year
 

data/lib/active_support/core_ext/time/marshal.rb

@@ -37,6 +37,7 @@ if Time.local(2010).zone != Marshal.load(Marshal.dump(Time.local(2010))).zone
         time.instance_eval do
           if zone = defined?(@_zone) && remove_instance_variable('@_zone')
             ary = to_a
+            ary[0] += subsec if ary[0] == sec
             ary[-1] = zone
             utc? ? Time.utc(*ary) : Time.local(*ary)
           else

data/lib/active_support/descendants_tracker.rb

@@ -1,5 +1,3 @@
-require 'active_support/dependencies'
-
 module ActiveSupport
   # This module provides an internal implementation to track descendants
   # which is faster than iterating through ObjectSpace.
@@ -18,12 +16,16 @@ module ActiveSupport
     end
 
     def self.clear
-      @@direct_descendants.each do |klass, descendants|
-        if ActiveSupport::Dependencies.autoloaded?(klass)
-          @@direct_descendants.delete(klass)
-        else
-          descendants.reject! { |v| ActiveSupport::Dependencies.autoloaded?(v) }
+      if defined? ActiveSupport::Dependencies
+        @@direct_descendants.each do |klass, descendants|
+          if ActiveSupport::Dependencies.autoloaded?(klass)
+            @@direct_descendants.delete(klass)
+          else
+            descendants.reject! { |v| ActiveSupport::Dependencies.autoloaded?(v) }
+          end
         end
+      else
+        @@direct_descendants.clear
       end
     end
 

data/lib/active_support/duration.rb

@@ -10,6 +10,7 @@ module ActiveSupport
   #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
   class Duration < BasicObject
     attr_accessor :value, :parts
+    delegate :duplicable?, :to => :value # required when using ActiveSupport's BasicObject on 1.8
 
     def initialize(value, parts) #:nodoc:
       @value, @parts = value, parts

data/lib/active_support/hash_with_indifferent_access.rb

@@ -10,6 +10,10 @@ module ActiveSupport
       true
     end
 
+    def with_indifferent_access
+      dup
+    end
+
     def initialize(constructor = {})
       if constructor.is_a?(Hash)
         super()
@@ -58,8 +62,12 @@ module ActiveSupport
     #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
     #
     def update(other_hash)
-      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-      self
+      if other_hash.is_a? HashWithIndifferentAccess
+        super(other_hash)
+      else
+        other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+        self
+      end
     end
 
     alias_method :merge!, :update
@@ -140,8 +148,8 @@ module ActiveSupport
       end
 
       def convert_value(value)
-        if value.class == Hash
-          self.class.new_from_hash_copying_default(value)
+        if value.is_a? Hash
+          value.nested_under_indifferent_access
         elsif value.is_a?(Array)
           value.dup.replace(value.map { |e| convert_value(e) })
         else

data/lib/active_support/inflector/methods.rb

@@ -135,11 +135,13 @@ module ActiveSupport
     #   ordinalize(2)     # => "2nd"
     #   ordinalize(1002)  # => "1002nd"
     #   ordinalize(1003)  # => "1003rd"
+    #   ordinalize(-11)   # => "-11th"
+    #   ordinalize(-1021) # => "-1021st"
     def ordinalize(number)
-      if (11..13).include?(number.to_i % 100)
+      if (11..13).include?(number.to_i.abs % 100)
         "#{number}th"
       else
-        case number.to_i % 10
+        case number.to_i.abs % 10
           when 1; "#{number}st"
           when 2; "#{number}nd"
           when 3; "#{number}rd"
@@ -148,4 +150,4 @@ module ActiveSupport
       end
     end
   end
-end
+end

data/lib/active_support/json/encoding.rb

@@ -2,6 +2,7 @@ require 'active_support/core_ext/object/to_json'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/deprecation'
 require 'active_support/json/variable'
+require 'active_support/ordered_hash'
 
 require 'bigdecimal'
 require 'active_support/core_ext/big_decimal/conversions' # for #to_s
@@ -205,7 +206,9 @@ class Regexp
 end
 
 module Enumerable
-  def as_json(options = nil) to_a end #:nodoc:
+  def as_json(options = nil) #:nodoc:
+    to_a.as_json(options)
+  end
 end
 
 class Array

data/lib/active_support/log_subscriber/test_helper.rb

@@ -1,5 +1,6 @@
 require 'active_support/log_subscriber'
 require 'active_support/buffered_logger'
+require 'active_support/notifications'
 
 module ActiveSupport
   class LogSubscriber

data/lib/active_support/ordered_hash.rb

@@ -43,6 +43,10 @@ module ActiveSupport
       end
     end
 
+    def nested_under_indifferent_access
+      self
+    end
+
     # Hash is ordered in Ruby 1.9!
     if RUBY_VERSION < '1.9'
 

data/lib/active_support/secure_random.rb

@@ -1,205 +1,6 @@
-begin
-  require 'securerandom'
-rescue LoadError
-end
+require 'securerandom'
 
 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
-
-      # 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
-
-        unless 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
-
-      # 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
-
-      # 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
-
-      # 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
+  # Use Ruby's SecureRandom library.
+  SecureRandom = ::SecureRandom # :nodoc:
 end

data/lib/active_support/testing/performance.rb

@@ -1,38 +1,83 @@
-begin
-  require 'ruby-prof'
-
-  require 'fileutils'
-  require 'rails/version'
-  require 'active_support/core_ext/class/delegating_attributes'
-  require 'active_support/core_ext/string/inflections'
-
-  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
+require 'fileutils'
+require 'rails/version'
+require 'active_support/concern'
+require 'active_support/core_ext/class/delegating_attributes'
+require 'active_support/core_ext/string/inflections'
+require 'action_view/helpers/number_helper'
+
+module ActiveSupport
+  module Testing
+    module Performance
+      extend ActiveSupport::Concern
+      
+      included do
+        superclass_delegating_accessor :profile_options
+        self.profile_options = {}
+
+        if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
+          include ForMiniTest
+        else
+          include ForClassicTestUnit
+        end
+      end
+      
+      # each implementation should define metrics and freeze the defaults
+      DEFAULTS =
+        if ARGV.include?('--benchmark') # HAX for rake test
+          { :runs => 4,
+            :output => 'tmp/performance',
+            :benchmark => true }
+        else
+          { :runs => 1,
+            :output => 'tmp/performance',
+            :benchmark => false }
         end
+      
+      def full_profile_options
+        DEFAULTS.merge(profile_options)
+      end
 
-        def full_test_name
-          "#{self.class.name}##{method_name}"
+      def full_test_name
+        "#{self.class.name}##{method_name}"
+      end
+      
+      module ForMiniTest
+        def run(runner)
+          @runner = runner
+
+          run_warmup
+          if full_profile_options && metrics = full_profile_options[:metrics]
+            metrics.each do |metric_name|
+              if klass = Metrics[metric_name.to_sym]
+                run_profile(klass.new)
+              end
+            end
+          end
+          
+          return
         end
 
+        def run_test(metric, mode)
+          result = '.'
+          begin
+            run_callbacks :setup
+            setup
+            metric.send(mode) { __send__ method_name }
+          rescue Exception => e
+            result = @runner.puke(self.class, method_name, e)
+          ensure
+            begin
+              teardown
+              run_callbacks :teardown, :enumerator => :reverse_each
+            rescue Exception => e
+              result = @runner.puke(self.class, method_name, e)
+            end
+          end
+          result
+        end
+      end
+
+      module ForClassicTestUnit
         def run(result)
           return if method_name =~ /^default_test$/
 
@@ -40,11 +85,13 @@ begin
           @_result = result
 
           run_warmup
-          if profile_options && metrics = profile_options[:metrics]
+          if full_profile_options && metrics = full_profile_options[:metrics]
             metrics.each do |metric_name|
               if klass = Metrics[metric_name.to_sym]
                 run_profile(klass.new)
                 result.add_run
+              else
+                puts '%20s: unsupported' % metric_name
               end
             end
           end
@@ -57,7 +104,7 @@ begin
           setup
           metric.send(mode) { __send__ @method_name }
         rescue ::Test::Unit::AssertionFailedError => e
-          add_failure(e.message, e.backtrace)
+        add_failure(e.message, e.backtrace)
         rescue StandardError, ScriptError => e
           add_error(e)
         ensure
@@ -70,356 +117,201 @@ begin
             add_error(e)
           end
         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
+      protected
+        # overridden by each implementation
+        def run_gc; end
+      
+        def run_warmup
+          run_gc
 
-          def run_profile(metric)
-            klass = profile_options[:benchmark] ? Benchmarker : Profiler
-            performer = klass.new(self, metric)
+          time = Metrics::Time.new
+          run_test(time, :benchmark)
+          puts "%s (%s warmup)" % [full_test_name, time.format(time.total)]
 
-            performer.run
-            puts performer.report
-            performer.record
-          end
+          run_gc
+        end
+        
+        def run_profile(metric)
+          klass = full_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
+      class Performer
+        delegate :run_test, :full_profile_options, :full_test_name, :to => :@harness
 
-          def initialize(harness, metric)
-            @harness, @metric = harness, metric
-          end
+        def initialize(harness, metric)
+          @harness, @metric, @supported = harness, metric, false
+        end
 
-          def report
-            rate = @total / profile_options[:runs]
+        def report
+          if @supported
+            rate = @total / full_profile_options[:runs]
             '%20s: %s' % [@metric.name, @metric.format(rate)]
+          else
+            '%20s: unsupported' % @metric.name
           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
+        protected
+          def output_filename
+            "#{full_profile_options[:output]}/#{full_test_name}_#{@metric.name}"
           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
+      
+      # overridden by each implementation
+      class Profiler < Performer
+        def time_with_block
+          before = Time.now
+          yield
+          Time.now - before
         end
+        
+        def run;    end
+        def record; 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.max.total_time }
-          end
+      class Benchmarker < Performer     
+        def initialize(*args)
+          super
+          @supported = @metric.respond_to?('measure')
+        end
+           
+        def run
+          return unless @supported
+          
+          full_profile_options[:runs].to_i.times { run_test(@metric, :benchmark) }
+          @total = @metric.total
+        end
 
-          def report
-            if @supported
-              super
-            else
-              '%20s: unsupported' % @metric.name
-            end
+        def record
+          avg = @metric.total / full_profile_options[:runs].to_i
+          now = Time.now.utc.xmlschema
+          with_output_file do |file|
+            file.puts "#{avg},#{now},#{environment}"
           end
+        end
 
-          def record
-            return unless @supported
-
-            klasses = profile_options[:formats].map { |f| RubyProf.const_get("#{f.to_s.camelize}Printer") }.compact
+        def environment
+          unless defined? @env
+            app = "#{$1}.#{$2}" if File.directory?('.git') && `git branch -v` =~ /^\* (\S+)\s+(\S+)/
 
-            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))
+            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
-          end
 
-          protected
-            def output_filename(printer_class)
-              suffix =
-                case printer_class.name.demodulize
-                  when 'FlatPrinter';                 'flat.txt'
-                  when 'FlatPrinterWithLineNumbers';  'flat_line_numbers.txt'
-                  when 'GraphPrinter';                'graph.txt'
-                  when 'GraphHtmlPrinter';            'graph.html'
-                  when 'GraphYamlPrinter';            'graph.yml'
-                  when 'CallTreePrinter';             'tree.txt'
-                  when 'CallStackPrinter';            'stack.html'
-                  when 'DotPrinter';                  'graph.dot'
-                  else printer_class.name.sub(/Printer$/, '').underscore
-                end
-
-              "#{super()}_#{suffix}"
-            end
-        end
+            ruby = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
+            ruby += "-#{RUBY_VERSION}.#{RUBY_PATCHLEVEL}"
 
-        module Metrics
-          def self.[](name)
-            const_get(name.to_s.camelize)
-          rescue NameError
-            nil
+            @env = [app, rails, ruby, RUBY_PLATFORM] * ','
           end
 
-          class Base
-            attr_reader :total
-
-            def initialize
-              @total = 0
-            end
-
-            def name
-              @name ||= self.class.name.demodulize.underscore
-            end
+          @env
+        end
 
-            def measure_mode
-              self.class::Mode
-            end
+        protected
+          HEADER = 'measurement,created_at,app,rails,ruby,platform'
 
-            def measure
-              0
-            end
+          def with_output_file
+            fname = output_filename
 
-            def benchmark
-              with_gc_stats do
-                before = measure
-                yield
-                @total += (measure - before)
-              end
+            if new = !File.exist?(fname)
+              FileUtils.mkdir_p(File.dirname(fname))
             end
 
-            def profile
-              RubyProf.resume
-              yield
-            ensure
-              RubyProf.pause
+            File.open(fname, 'ab') do |file|
+              file.puts(HEADER) if new
+              yield file
             end
-
-            protected
-              # Ruby 1.9 with GC::Profiler
-              if defined?(GC::Profiler)
-                def with_gc_stats
-                  GC::Profiler.enable
-                  GC.start
-                  yield
-                ensure
-                  GC::Profiler.disable
-                end
-
-              # Ruby 1.8 + ruby-prof wrapper (enable/disable stats for Benchmarker)
-              elsif GC.respond_to?(:enable_stats)
-                def with_gc_stats
-                  GC.enable_stats
-                  yield
-                ensure
-                  GC.disable_stats
-                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 < 1
-                '%d ms' % (measurement * 1000)
-              else
-                '%.2f sec' % measurement
-              end
-            end
+          def output_filename
+            "#{super}.csv"
           end
+      end
+      
+      module Metrics
+        def self.[](name)
+          const_get(name.to_s.camelize)
+        rescue NameError
+          nil
+        end
 
-          class ProcessTime < Time
-            Mode = RubyProf::PROCESS_TIME
+        class Base
+          include ActionView::Helpers::NumberHelper
+          
+          attr_reader :total
 
-            def measure
-              RubyProf.measure_process_time
-            end
+          def initialize
+            @total = 0
           end
 
-          class WallTime < Time
-            Mode = RubyProf::WALL_TIME
-
-            def measure
-              RubyProf.measure_wall_time
-            end
+          def name
+            @name ||= self.class.name.demodulize.underscore
           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 unless RubyProf.cpu_frequency > 0
-              super
-            end
-
-            def measure
-              RubyProf.measure_cpu_time
+          def benchmark            
+            with_gc_stats do
+              before = measure
+              yield
+              @total += (measure - before)
             end
           end
-
-          class Memory < Base
-            Mode = RubyProf::MEMORY if RubyProf.const_defined?(:MEMORY)
-
-            # Ruby 1.9 + GCdata patch
-            if GC.respond_to?(:malloc_allocated_size)
-              def measure
-                GC.malloc_allocated_size / 1024.0
-              end
-
-            # Ruby 1.8 + ruby-prof wrapper
-            elsif RubyProf.respond_to?(:measure_memory)
-              def measure
-                RubyProf.measure_memory / 1024.0
-              end
-            end
-
-            def format(measurement)
-              '%.2f KB' % measurement
-            end
+          
+          # overridden by each implementation
+          def profile; end
+            
+          protected
+            # overridden by each implementation
+            def with_gc_stats; end
+        end
+        
+        class Time < Base
+          def measure
+            ::Time.now.to_f
           end
 
-          class Objects < Base
-            Mode = RubyProf::ALLOCATIONS if RubyProf.const_defined?(:ALLOCATIONS)
-
-            # Ruby 1.9 + GCdata patch
-            if GC.respond_to?(:malloc_allocations)
-              def measure
-                GC.malloc_allocations
-              end
-
-            # Ruby 1.8 + ruby-prof wrapper
-            elsif RubyProf.respond_to?(:measure_allocations)
-              def measure
-                RubyProf.measure_allocations
-              end
-            end
-
-            def format(measurement)
-              measurement.to_i.to_s
+          def format(measurement)
+            if measurement < 1
+              '%d ms' % (measurement * 1000)
+            else
+              '%.2f sec' % measurement
             end
           end
-
-          class GcRuns < Base
-            Mode = RubyProf::GC_RUNS if RubyProf.const_defined?(:GC_RUNS)
-
-            # Ruby 1.9
-            if GC.respond_to?(:count)
-              def measure
-                GC.count
-              end
-
-            # Ruby 1.8 + ruby-prof wrapper
-            elsif RubyProf.respond_to?(:measure_gc_runs)
-              def measure
-                RubyProf.measure_gc_runs
-              end
-            end
-
-            def format(measurement)
-              measurement.to_i.to_s
-            end
+        end
+        
+        class Amount < Base
+          def format(measurement)
+            number_with_delimiter(measurement.floor)
           end
-
-          class GcTime < Base
-            Mode = RubyProf::GC_TIME if RubyProf.const_defined?(:GC_TIME)
-
-            # Ruby 1.9 with GC::Profiler
-            if defined?(GC::Profiler) && GC::Profiler.respond_to?(:total_time)
-              def measure
-                GC::Profiler.total_time
-              end
-
-            # Ruby 1.8 + ruby-prof wrapper
-            elsif RubyProf.respond_to?(:measure_gc_time)
-              def measure
-                RubyProf.measure_gc_time / 1000
-              end
-            end
-
-            def format(measurement)
-              '%.2f ms' % measurement
-            end
+        end
+        
+        class DigitalInformationUnit < Base
+          def format(measurement)
+            number_to_human_size(measurement, :precision => 2)
           end
         end
+        
+        # each implementation provides its own metrics like ProcessTime, Memory or GcRuns
       end
     end
   end
-rescue LoadError
+end
+
+RUBY_ENGINE = 'ruby' unless defined?(RUBY_ENGINE) # mri 1.8
+case RUBY_ENGINE
+  when 'ruby'   then require 'active_support/testing/performance/ruby'
+  when 'rbx'    then require 'active_support/testing/performance/rubinius'
+  when 'jruby'  then require 'active_support/testing/performance/jruby'
+  else
+    $stderr.puts 'Your ruby interpreter is not supported for benchmarking.'
+    exit
 end