activesupport 2.3.18 → 3.0.0.beta

data/lib/active_support/ordered_options.rb

@@ -1,5 +1,7 @@
+require 'active_support/ordered_hash'
+
 module ActiveSupport #:nodoc:
-  class OrderedOptions < OrderedHash #:nodoc:
+  class OrderedOptions < OrderedHash
     def []=(key, value)
       super(key.to_sym, value)
     end

data/lib/active_support/railtie.rb

@@ -0,0 +1,64 @@
+require "active_support"
+require "rails"
+
+module ActiveSupport
+  class Railtie < Rails::Railtie
+    railtie_name :active_support
+
+    # Loads support for "whiny nil" (noisy warnings when methods are invoked
+    # on +nil+ values) if Configuration#whiny_nils is true.
+    initializer "active_support.initialize_whiny_nils" do |app|
+      require 'active_support/whiny_nil' if app.config.whiny_nils
+    end
+
+    # Sets the default value for Time.zone
+    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
+    initializer "active_support.initialize_time_zone" do |app|
+      require 'active_support/core_ext/time/zones'
+      zone_default = Time.__send__(:get_zone, app.config.time_zone)
+
+      unless zone_default
+        raise \
+          'Value assigned to config.time_zone not recognized.' +
+          'Run "rake -D time" for a list of tasks for finding appropriate time zone names.'
+      end
+
+      Time.zone_default = zone_default
+    end
+  end
+end
+
+module I18n
+  class Railtie < Rails::Railtie
+    railtie_name :i18n
+
+    # Initialize I18n load paths to an array
+    config.i18n.engines_load_path = []
+    config.i18n.load_path = []
+
+    initializer "i18n.initialize" do
+      require 'active_support/i18n'
+
+      ActionDispatch::Callbacks.to_prepare do
+        I18n.reload!
+      end
+    end
+
+    # Set the i18n configuration from config.i18n but special-case for
+    # the load_path which should be appended to what's already set instead of overwritten.
+    config.after_initialize do |app|
+      app.config.i18n.each do |setting, value|
+        case setting
+        when :engines_load_path
+          app.config.i18n.load_path.unshift(*value)
+        when :load_path
+          I18n.load_path += value
+        else
+          I18n.send("#{setting}=", value)
+        end
+      end
+
+      I18n.reload!
+    end
+  end
+end

data/lib/active_support/rescuable.rb

@@ -1,11 +1,16 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/proc'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/array/extract_options'
+
 module ActiveSupport
   # Rescuable module adds support for easier exception handling.
   module Rescuable
-    def self.included(base) # :nodoc:
-      base.class_inheritable_accessor :rescue_handlers
-      base.rescue_handlers = []
+    extend Concern
 
-      base.extend(ClassMethods)
+    included do
+      class_attribute :rescue_handlers
+      self.rescue_handlers = []
     end
 
     module ClassMethods
@@ -62,7 +67,7 @@ module ActiveSupport
           end
 
           # put the new handler at the end because the list is read in reverse
-          rescue_handlers << [key, options[:with]]
+          self.rescue_handlers += [[key, options[:with]]]
         end
       end
     end
@@ -78,7 +83,7 @@ module ActiveSupport
     def handler_for_rescue(exception)
       # We go from right to left because pairs are pushed onto rescue_handlers
       # as rescue_from declarations are found.
-      _, rescuer = Array(rescue_handlers).reverse.detect do |klass_name, handler|
+      _, rescuer = self.class.rescue_handlers.reverse.detect do |klass_name, handler|
         # The purpose of allowing strings in rescue_from is to support the
         # declaration of handler associations for exception classes whose
         # definition is yet unknown.

data/lib/active_support/ruby/shim.rb

@@ -0,0 +1,19 @@
+# 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/rexml'
+require 'active_support/core_ext/time/conversions'

data/lib/active_support/test_case.rb

@@ -3,9 +3,10 @@ require 'active_support/testing/setup_and_teardown'
 require 'active_support/testing/assertions'
 require 'active_support/testing/deprecation'
 require 'active_support/testing/declarative'
+require 'active_support/testing/pending'
+require 'active_support/testing/isolation'
 
 begin
-  gem 'mocha', ">= 0.9.7"
   require 'mocha'
 rescue LoadError
   # Fake Mocha::ExpectationError so we can rescue it in #run. Bleh.
@@ -32,9 +33,15 @@ module ActiveSupport
       include ActiveSupport::Testing::Default
     end
 
+    $tags = {}
+    def self.for_tag(tag)
+      yield if $tags[tag]
+    end
+
     include ActiveSupport::Testing::SetupAndTeardown
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::Deprecation
+    include ActiveSupport::Testing::Pending
     extend ActiveSupport::Testing::Declarative
   end
 end

data/lib/active_support/testing/assertions.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array/wrap'
+
 module ActiveSupport
   module Testing
     module Assertions
@@ -60,20 +62,6 @@ module ActiveSupport
       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/lib/active_support/testing/declarative.rb

@@ -1,18 +1,37 @@
 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}"
+      
+      def self.extended(klass)
+        klass.class_eval do
+          
+          unless method_defined?(:describe)
+            def self.describe(text)
+              class_eval <<-RUBY_EVAL
+                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

data/lib/active_support/testing/deprecation.rb

@@ -1,4 +1,4 @@
-require "active_support/core_ext/module"
+require 'active_support/deprecation'
 
 module ActiveSupport
   module Testing
@@ -37,21 +37,19 @@ end
 
 begin
   require 'test/unit/error'
-
+rescue LoadError
+  # Using miniunit, ignore.
+else
   module Test
     module Unit
-      class Error # :nodoc:
+      class Error #:nodoc:
         # Silence warnings when reporting test errors.
         def message_with_silenced_deprecation
-          ActiveSupport::Deprecation.silence do
-            message_without_silenced_deprecation
-          end
+          ActiveSupport::Deprecation.silence { message_without_silenced_deprecation }
         end
-
-        alias_method_chain :message, :silenced_deprecation
+        alias_method :message_without_silenced_deprecation, :message
+        alias_method :message, :message_with_silenced_deprecation
       end
     end
   end
-rescue LoadError
-  # Using miniunit, ignore.
 end

data/lib/active_support/testing/isolation.rb

@@ -0,0 +1,153 @@
+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"] && RUBY_PLATFORM !~ /mswin|mingw|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 |runner|
+            super(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

@@ -0,0 +1,48 @@
+# 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