activesupport 3.2.22.5 → 4.0.0.beta1

data/lib/active_support/multibyte/exceptions.rb

@@ -1,8 +0,0 @@
-# encoding: utf-8
-
-module ActiveSupport #:nodoc:
-  module Multibyte #:nodoc:
-    # Raised when a problem with the encoding was found.
-    class EncodingError < StandardError; end
-  end
-end

data/lib/active_support/multibyte/utils.rb

@@ -1,60 +0,0 @@
-# encoding: utf-8
-
-module ActiveSupport #:nodoc:
-  module Multibyte #:nodoc:
-    if Kernel.const_defined?(:Encoding)
-      # Returns a regular expression that matches valid characters in the current encoding
-      def self.valid_character
-        VALID_CHARACTER[Encoding.default_external.to_s]
-      end
-    else
-      def self.valid_character
-        case $KCODE
-        when 'UTF8'
-          VALID_CHARACTER['UTF-8']
-        when 'SJIS'
-          VALID_CHARACTER['Shift_JIS']
-        end
-      end
-    end
-
-    if 'string'.respond_to?(:valid_encoding?)
-      # Verifies the encoding of a string
-      def self.verify(string)
-        string.valid_encoding?
-      end
-    else
-      def self.verify(string)
-        if expression = valid_character
-          # Splits the string on character boundaries, which are determined based on $KCODE.
-          string.split(//).all? { |c| expression =~ c }
-        else
-          true
-        end
-      end
-    end
-
-    # Verifies the encoding of the string and raises an exception when it's not valid
-    def self.verify!(string)
-      raise EncodingError.new("Found characters with invalid encoding") unless verify(string)
-    end
-
-    if 'string'.respond_to?(:force_encoding)
-      # Removes all invalid characters from the string.
-      #
-      # Note: this method is a no-op in Ruby 1.9
-      def self.clean(string)
-        string
-      end
-    else
-      def self.clean(string)
-        if expression = valid_character
-          # Splits the string on character boundaries, which are determined based on $KCODE.
-          string.split(//).grep(expression).join
-        else
-          string
-        end
-      end
-    end
-  end
-end

data/lib/active_support/ruby/shim.rb

@@ -1,22 +0,0 @@
-# Backported Ruby builtins so you can code with the latest & greatest
-# but still run on any Ruby 1.8.x.
-#
-# Date        next_year, next_month
-# DateTime    to_date, to_datetime, xmlschema
-# Enumerable  group_by, each_with_object, none?
-# Process     Process.daemon
-# REXML       security fix
-# String      ord
-# Time        to_date, to_time, to_datetime
-require 'active_support'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/process/daemon'
-require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/interpolation'
-require 'active_support/core_ext/string/encoding'
-require 'active_support/core_ext/rexml'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/file/path'
-require 'active_support/core_ext/module/method_names'

data/lib/active_support/security_utils.rb

@@ -1,27 +0,0 @@
-require 'digest'
-
-module ActiveSupport
-  module SecurityUtils
-    # Constant time string comparison.
-    #
-    # The values compared should be of fixed length, such as strings
-    # that have already been processed by HMAC. This should not be used
-    # on variable length plaintext strings because it could leak length info
-    # via timing attacks.
-    def secure_compare(a, b)
-      return false unless a.bytesize == b.bytesize
-
-      l = a.unpack "C#{a.bytesize}"
-
-      res = 0
-      b.each_byte { |byte| res |= byte ^ l.shift }
-      res == 0
-    end
-    module_function :secure_compare
-
-    def variable_size_secure_compare(a, b) # :nodoc:
-      secure_compare(::Digest::SHA256.hexdigest(a), ::Digest::SHA256.hexdigest(b))
-    end
-    module_function :variable_size_secure_compare
-  end
-end

data/lib/active_support/testing/mochaing.rb

@@ -1,7 +0,0 @@
-begin
-  silence_warnings { require 'mocha/setup' }
-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

data/lib/active_support/testing/performance.rb

@@ -1,317 +0,0 @@
-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 ENV["BENCHMARK_TESTS"]
-          { :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}"
-      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$/
-
-          yield(self.class::STARTED, name)
-          @_result = result
-
-          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)
-                result.add_run
-              else
-                puts '%20s: unsupported' % metric_name
-              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 => e
-          add_error(e)
-        ensure
-          begin
-            teardown
-            run_callbacks :teardown, :enumerator => :reverse_each
-          rescue ::Test::Unit::AssertionFailedError => e
-            add_failure(e.message, e.backtrace)
-          rescue StandardError, ScriptError => e
-            add_error(e)
-          end
-        end
-      end
-
-      protected
-        # overridden by each implementation
-        def run_gc; end
-
-        def run_warmup
-          run_gc
-
-          time = Metrics::Time.new
-          run_test(time, :benchmark)
-          puts "%s (%s warmup)" % [full_test_name, time.format(time.total)]
-
-          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, :full_profile_options, :full_test_name, :to => :@harness
-
-        def initialize(harness, metric)
-          @harness, @metric, @supported = harness, metric, false
-        end
-
-        def report
-          if @supported
-            rate = @total / full_profile_options[:runs]
-            '%20s: %s' % [@metric.name, @metric.format(rate)]
-          else
-            '%20s: unsupported' % @metric.name
-          end
-        end
-
-        protected
-          def output_filename
-            "#{full_profile_options[:output]}/#{full_test_name}_#{@metric.name}"
-          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 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 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 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
-
-      module Metrics
-        def self.[](name)
-          const_get(name.to_s.camelize)
-        rescue NameError
-          nil
-        end
-
-        class Base
-          include ActionView::Helpers::NumberHelper
-
-          attr_reader :total
-
-          def initialize
-            @total = 0
-          end
-
-          def name
-            @name ||= self.class.name.demodulize.underscore
-          end
-
-          def benchmark            
-            with_gc_stats do
-              before = measure
-              yield
-              @total += (measure - before)
-            end
-          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
-
-          def format(measurement)
-            if measurement < 1
-              '%d ms' % (measurement * 1000)
-            else
-              '%.2f sec' % measurement
-            end
-          end
-        end
-
-        class Amount < Base
-          def format(measurement)
-            number_with_delimiter(measurement.floor)
-          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
-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

data/lib/active_support/testing/performance/jruby.rb

@@ -1,115 +0,0 @@
-require 'jruby/profiler'
-require 'java'
-java_import java.lang.management.ManagementFactory
-
-module ActiveSupport
-  module Testing
-    module Performance
-      DEFAULTS.merge!(
-        if ENV["BENCHMARK_TESTS"]
-          {:metrics => [:wall_time, :user_time, :memory, :gc_runs, :gc_time]}
-        else
-          { :metrics => [:wall_time],
-            :formats => [:flat, :graph] }
-        end).freeze
-
-      protected
-        def run_gc
-          ManagementFactory.memory_mx_bean.gc
-        end
-
-      class Profiler < Performer
-        def initialize(*args)
-          super
-          @supported = @metric.is_a?(Metrics::WallTime)
-        end
-
-        def run
-          return unless @supported
-
-          @total = time_with_block do
-            @data = JRuby::Profiler.profile do
-              full_profile_options[:runs].to_i.times { run_test(@metric, :profile) }
-            end
-          end
-        end
-
-        def record
-          return unless @supported
-
-          klasses = full_profile_options[:formats].map { |f| JRuby::Profiler.const_get("#{f.to_s.camelize}ProfilePrinter") }.compact
-
-          klasses.each do |klass|
-            fname = output_filename(klass)
-            FileUtils.mkdir_p(File.dirname(fname))
-            file = File.open(fname, 'wb') do |file|
-              klass.new(@data).printProfile(file)
-            end
-          end
-        end
-
-        protected
-          def output_filename(printer_class)
-            suffix =
-              case printer_class.name.demodulize
-                when 'FlatProfilePrinter';  'flat.txt'
-                when 'GraphProfilePrinter'; 'graph.txt'
-                else printer_class.name.sub(/ProfilePrinter$/, '').underscore
-              end
-
-            "#{super()}_#{suffix}"
-          end
-      end
-
-      module Metrics
-        class Base
-          def profile
-            yield
-          end
-
-          protected
-            def with_gc_stats
-              ManagementFactory.memory_mx_bean.gc
-              yield
-            end
-        end
-
-        class WallTime < Time
-          def measure
-            super
-          end
-        end
-
-        class CpuTime < Time
-          def measure
-            ManagementFactory.thread_mx_bean.get_current_thread_cpu_time / 1000 / 1000 / 1000.0 # seconds
-          end
-        end
-
-        class UserTime < Time
-          def measure
-            ManagementFactory.thread_mx_bean.get_current_thread_user_time / 1000 / 1000 / 1000.0 # seconds
-          end
-        end
-
-        class Memory < DigitalInformationUnit
-          def measure
-            ManagementFactory.memory_mx_bean.non_heap_memory_usage.used + ManagementFactory.memory_mx_bean.heap_memory_usage.used
-          end
-        end
-
-        class GcRuns < Amount
-          def measure
-            ManagementFactory.garbage_collector_mx_beans.inject(0) { |total_runs, current_gc| total_runs += current_gc.collection_count }
-          end
-        end
-
-        class GcTime < Time
-          def measure
-            ManagementFactory.garbage_collector_mx_beans.inject(0) { |total_time, current_gc| total_time += current_gc.collection_time } / 1000.0 # seconds
-          end
-        end
-      end
-    end
-  end
-end