csd 0.1.5 → 0.1.6

data/lib/active_support/testing/declarative.rb

@@ -1,40 +0,0 @@
-module ActiveSupport
-  module Testing
-    module Declarative
-      
-      def self.extended(klass)
-        klass.class_eval do
-          
-          unless method_defined?(:describe)
-            def self.describe(text)
-              class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-                def self.name
-                  "#{text}"
-                end
-              RUBY_EVAL
-            end
-          end
-          
-        end
-      end 
-
-      unless defined?(Spec)
-        # 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
-end

data/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/lib/active_support/testing/deprecation.rb

@@ -1,55 +0,0 @@
-require 'active_support/deprecation'
-
-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'
-rescue LoadError
-  # Using miniunit, ignore.
-else
-  module Test
-    module Unit
-      class Error #:nodoc:
-        # Silence warnings when reporting test errors.
-        def message_with_silenced_deprecation
-          ActiveSupport::Deprecation.silence { message_without_silenced_deprecation }
-        end
-        alias_method :message_without_silenced_deprecation, :message
-        alias_method :message, :message_with_silenced_deprecation
-      end
-    end
-  end
-end

data/lib/active_support/testing/isolation.rb

@@ -1,154 +0,0 @@
-require 'rbconfig'
-module ActiveSupport
-  module Testing
-    class RemoteError < StandardError
-
-      attr_reader :message, :backtrace
-
-      def initialize(exception)
-        @message = "caught #{exception.class.name}: #{exception.message}"
-        @backtrace = exception.backtrace
-      end
-    end
-
-    class ProxyTestResult
-      def initialize
-        @calls = []
-      end
-
-      def add_error(e)
-        e = Test::Unit::Error.new(e.test_name, RemoteError.new(e.exception))
-        @calls << [:add_error, e]
-      end
-
-      def __replay__(result)
-        @calls.each do |name, args|
-          result.send(name, *args)
-        end
-      end
-
-      def method_missing(name, *args)
-        @calls << [name, args]
-      end
-    end
-
-    module Isolation
-      def self.forking_env?
-        !ENV["NO_FORK"] && ((Config::CONFIG['host_os'] !~ /mswin|mingw/) && (RUBY_PLATFORM !~ /java/))
-      end
-
-      def self.included(base)
-        if defined?(::MiniTest) && base < ::MiniTest::Unit::TestCase
-          base.send :include, MiniTest
-        elsif defined?(Test::Unit)
-          base.send :include, TestUnit
-        end
-      end
-
-      module TestUnit
-        def run(result)
-          unless defined?(@@ran_class_setup)
-            self.class.setup if self.class.respond_to?(:setup)
-            @@ran_class_setup = true
-          end
-
-          yield(Test::Unit::TestCase::STARTED, name)
-
-          @_result = result
-
-          serialized = run_in_isolation do |proxy|
-            begin
-              super(proxy) { }
-            rescue Exception => e
-              proxy.add_error(Test::Unit::Error.new(name, e))
-            end
-          end
-
-          retval, proxy = Marshal.load(serialized)
-          proxy.__replay__(@_result)
-
-          yield(Test::Unit::TestCase::FINISHED, name)
-          retval
-        end
-      end
-
-      module MiniTest
-        def run(runner)
-          unless defined?(@@ran_class_setup)
-            self.class.setup if self.class.respond_to?(:setup)
-            @@ran_class_setup = true
-          end
-
-          serialized = run_in_isolation do |isolated_runner|
-            super(isolated_runner)
-          end
-
-          retval, proxy = Marshal.load(serialized)
-          proxy.__replay__(runner)
-          retval
-        end
-      end
-
-      module Forking
-        def run_in_isolation(&blk)
-          read, write = IO.pipe
-
-          pid = fork do
-            read.close
-            proxy = ProxyTestResult.new
-            retval = yield proxy
-            write.puts [Marshal.dump([retval, proxy])].pack("m")
-            exit!
-          end
-
-          write.close
-          result = read.read
-          Process.wait2(pid)
-          return result.unpack("m")[0]
-        end
-      end
-
-      module Subprocess
-        # Crazy H4X to get this working in windows / jruby with
-        # no forking.
-        def run_in_isolation(&blk)
-          require "tempfile"
-
-          if ENV["ISOLATION_TEST"]
-            proxy = ProxyTestResult.new
-            retval = yield proxy
-            File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-              file.puts [Marshal.dump([retval, proxy])].pack("m")
-            end
-            exit!
-          else
-            Tempfile.open("isolation") do |tmpfile|
-              ENV["ISOLATION_TEST"]   = @method_name
-              ENV["ISOLATION_OUTPUT"] = tmpfile.path
-
-              load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
-              `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
-
-              ENV.delete("ISOLATION_TEST")
-              ENV.delete("ISOLATION_OUTPUT")
-
-              return tmpfile.read.unpack("m")[0]
-            end
-          end
-        end
-      end
-
-      include forking_env? ? Forking : Subprocess
-    end
-  end
-end
-
-# Only in subprocess for windows / jruby.
-if ENV['ISOLATION_TEST']
-  require "test/unit/collector/objectspace"
-  class Test::Unit::Collector::ObjectSpace
-    def include?(test)
-      super && test.method_name == ENV['ISOLATION_TEST']
-    end
-  end
-end

data/lib/active_support/testing/pending.rb

@@ -1,48 +0,0 @@
-# Some code from jeremymcanally's "pending"
-# http://github.com/jeremymcanally/pending/tree/master
-
-module ActiveSupport
-  module Testing
-    module Pending
-
-      unless defined?(Spec)
-
-        @@pending_cases = []
-        @@at_exit = false
-
-        def pending(description = "", &block)
-          if description.is_a?(Symbol)
-            is_pending = $tags[description]
-            return block.call unless is_pending
-          end
-
-          if block_given?
-            failed = false
-
-            begin
-              block.call
-            rescue Exception
-              failed = true
-            end
-
-            flunk("<#{description}> did not fail.") unless failed 
-          end
-
-          caller[0] =~ (/(.*):(.*):in `(.*)'/)
-          @@pending_cases << "#{$3} at #{$1}, line #{$2}"
-          print "P"
-      
-          @@at_exit ||= begin
-            at_exit do
-              puts "\nPending Cases:"
-              @@pending_cases.each do |test_case|
-                puts test_case
-              end
-            end
-          end
-        end
-      end
-      
-    end
-  end
-end

data/lib/active_support/testing/performance.rb

@@ -1,455 +0,0 @@
-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
-        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
-rescue LoadError
-end