activesupport 3.0.pre → 3.0.0.rc

data/lib/active_support/notifications/fanout.rb

@@ -0,0 +1,61 @@
+module ActiveSupport
+  module Notifications
+    # This is a default queue implementation that ships with Notifications. It
+    # just pushes events to all registered log subscribers.
+    class Fanout
+      def initialize
+        @subscribers = []
+        @listeners_for = {}
+      end
+
+      def subscribe(pattern = nil, block = Proc.new)
+        subscriber = Subscriber.new(pattern, block).tap do |s|
+          @subscribers << s
+        end
+        @listeners_for.clear
+        subscriber
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.reject! {|s| s.matches?(subscriber)}
+        @listeners_for.clear
+      end
+
+      def publish(name, *args)
+        listeners_for(name).each { |s| s.publish(name, *args) }
+      end
+
+      def listeners_for(name)
+        @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }
+      end
+
+      def listening?(name)
+        listeners_for(name).any?
+      end
+
+      # This is a sync queue, so there is not waiting.
+      def wait
+      end
+
+      class Subscriber #:nodoc:
+        def initialize(pattern, delegate)
+          @pattern = pattern
+          @delegate = delegate
+        end
+
+        def publish(message, *args)
+          @delegate.call(message, *args)
+        end
+
+        def subscribed_to?(name)
+          !@pattern || @pattern === name.to_s
+        end
+
+        def matches?(subscriber_or_name)
+          self === subscriber_or_name ||
+            @pattern && @pattern === subscriber_or_name
+        end
+      end
+    end
+  end
+end

data/lib/active_support/notifications/instrumenter.rb

@@ -0,0 +1,54 @@
+require 'active_support/secure_random'
+require 'active_support/core_ext/module/delegation'
+
+module ActiveSupport
+  module Notifications
+    class Instrumenter
+      attr_reader :id
+
+      def initialize(notifier)
+        @id = unique_id
+        @notifier = notifier
+      end
+
+      # Instrument the given block by measuring the time taken to execute it
+      # and publish it. Notice that events get sent even if an error occurs
+      # in the passed-in block
+      def instrument(name, payload={})
+        started = Time.now
+
+        begin
+          yield
+        rescue Exception => e
+          payload[:exception] = [e.class.name, e.message]
+          raise e
+        ensure
+          @notifier.publish(name, started, Time.now, @id, payload)
+        end
+      end
+
+      private
+        def unique_id
+          SecureRandom.hex(10)
+        end
+    end
+
+    class Event
+      attr_reader :name, :time, :end, :transaction_id, :payload, :duration
+
+      def initialize(name, start, ending, transaction_id, payload)
+        @name           = name
+        @payload        = payload.dup
+        @time           = start
+        @transaction_id = transaction_id
+        @end            = ending
+        @duration       = 1000.0 * (@end - @time)
+      end
+
+      def parent_of?(event)
+        start = (time - event.time) * 1000
+        start <= 0 && (start + duration >= event.duration)
+      end
+    end
+  end
+end

data/lib/active_support/ordered_hash.rb

@@ -1,10 +1,39 @@
+require 'yaml'
+
+YAML.add_builtin_type("omap") do |type, val|
+  ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
+end
+
 # OrderedHash is namespaced to prevent conflicts with other implementations
 module ActiveSupport
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION >= '1.9'
-    OrderedHash = ::Hash
-  else
-    class OrderedHash < Hash #:nodoc:
+  class OrderedHash < ::Hash #:nodoc:
+    def to_yaml_type
+      "!tag:yaml.org,2002:omap"
+    end
+
+    def to_yaml(opts = {})
+      YAML.quick_emit(self, opts) do |out|
+        out.seq(taguri, to_yaml_style) do |seq|
+          each do |k, v|
+            seq.add(k => v)
+          end
+        end
+      end
+    end
+
+    # Hash is ordered in Ruby 1.9!
+    if RUBY_VERSION < '1.9'
+
+      # In MRI the Hash class is core and written in C. In particular, methods are
+      # programmed with explicit C function calls and polymorphism is not honored.
+      #
+      # For example, []= is crucial in this implementation to maintain the @keys
+      # array but hash.c invokes rb_hash_aset() originally. This prevents method
+      # reuse through inheritance and forces us to reimplement stuff.
+      #
+      # For instance, we cannot use the inherited #merge! because albeit the algorithm
+      # itself would work, our []= is not being called at all by the C code.
+
       def initialize(*args, &block)
         super
         @keys = []
@@ -52,7 +81,7 @@ module ActiveSupport
         end
         super
       end
-      
+
       def delete_if
         super
         sync_keys!
@@ -112,23 +141,39 @@ module ActiveSupport
       end
 
       def merge!(other_hash)
-        other_hash.each {|k,v| self[k] = v }
+        if block_given?
+          other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+        else
+          other_hash.each { |k, v| self[k] = v }
+        end
         self
       end
 
-      def merge(other_hash)
-        dup.merge!(other_hash)
+      alias_method :update, :merge!
+
+      def merge(other_hash, &block)
+        dup.merge!(other_hash, &block)
       end
 
-      def inspect
-        "#<OrderedHash #{super}>"
+      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+      def replace(other)
+        super
+        @keys = other.keys
+        self
       end
 
-    private
+      def invert
+        OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
+      end
 
-      def sync_keys!
-        @keys.delete_if {|k| !has_key?(k)}
+      def inspect
+        "#<OrderedHash #{super}>"
       end
+
+      private
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
+        end
     end
   end
 end

data/lib/active_support/ordered_options.rb

@@ -18,4 +18,10 @@ module ActiveSupport #:nodoc:
       end
     end
   end
+
+  class InheritableOptions < OrderedOptions
+    def initialize(parent)
+      super() { |h,k| parent[k] }
+    end
+  end
 end

data/lib/active_support/railtie.rb

@@ -0,0 +1,60 @@
+require "active_support"
+require "rails"
+require "active_support/i18n_railtie"
+
+module ActiveSupport
+  class Railtie < Rails::Railtie
+    config.active_support = ActiveSupport::OrderedOptions.new
+
+    # 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
+
+    initializer "active_support.deprecation_behavior" do |app|
+      if deprecation = app.config.active_support.deprecation
+        ActiveSupport::Deprecation.behavior = deprecation
+      else
+        defaults = {"development" => :log,
+                    "production"  => :notify,
+                    "test"        => :stderr}
+
+        env = Rails.env
+
+        if defaults.key?(env)
+          msg = "You did not specify how you would like Rails to report " \
+                "deprecation notices for your #{env} environment, please " \
+                "set config.active_support.deprecation to :#{defaults[env]} " \
+                "at config/environments/#{env}.rb"
+
+          warn msg
+          ActiveSupport::Deprecation.behavior = defaults[env]
+        else
+          msg = "You did not specify how you would like Rails to report " \
+                "deprecation notices for your #{env} environment, please " \
+                "set config.active_support.deprecation to :log, :notify or " \
+                ":stderr at config/environments/#{env}.rb"
+
+          warn msg
+          ActiveSupport::Deprecation.behavior = :stderr
+        end
+      end
+    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

data/lib/active_support/rescuable.rb

@@ -1,5 +1,8 @@
-require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/concern'
+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.
@@ -7,7 +10,7 @@ module ActiveSupport
     extend Concern
 
     included do
-      class_inheritable_accessor :rescue_handlers
+      class_attribute :rescue_handlers
       self.rescue_handlers = []
     end
 
@@ -65,7 +68,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
@@ -81,7 +84,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

@@ -4,21 +4,19 @@
 # Date        next_year, next_month
 # DateTime    to_date, to_datetime, xmlschema
 # Enumerable  group_by, each_with_object, none?
-# Integer     even?, odd?
-# Object      tap
 # Process     Process.daemon
 # REXML       security fix
 # String      ord
-# Symbol      to_proc
 # 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/integer/even_odd'
-require 'active_support/core_ext/object/tap'
 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/symbol/to_proc'
 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/test_case.rb

@@ -5,9 +5,10 @@ require 'active_support/testing/deprecation'
 require 'active_support/testing/declarative'
 require 'active_support/testing/pending'
 require 'active_support/testing/isolation'
+require 'active_support/core_ext/kernel/reporting'
 
 begin
-  require 'mocha'
+  silence_warnings { require 'mocha' }
 rescue LoadError
   # Fake Mocha::ExpectationError so we can rescue it in #run. Bleh.
   Object.const_set :Mocha, Module.new
@@ -21,12 +22,6 @@ module ActiveSupport
       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'

data/lib/active_support/testing/assertions.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/blank'
 
 module ActiveSupport
   module Testing
@@ -62,6 +63,20 @@ 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

@@ -7,7 +7,7 @@ module ActiveSupport
           
           unless method_defined?(:describe)
             def self.describe(text)
-              class_eval <<-RUBY_EVAL
+              class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
                 def self.name
                   "#{text}"
                 end

data/lib/active_support/testing/isolation.rb

@@ -1,10 +1,26 @@
+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)
@@ -18,31 +34,60 @@ module ActiveSupport
 
     module Isolation
       def self.forking_env?
-        !ENV["NO_FORK"] && RUBY_PLATFORM !~ /mswin|mingw|java/
+        !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
 
-      def run(result)
-        unless defined?(@@ran_class_setup)
+      def _run_class_setup      # class setup method should only happen in parent
+        unless defined?(@@ran_class_setup) || ENV['ISOLATION_TEST']
           self.class.setup if self.class.respond_to?(:setup)
           @@ran_class_setup = true
         end
+      end
+
+      module TestUnit
+        def run(result)
+          _run_class_setup
 
-        yield(Test::Unit::TestCase::STARTED, name)
+          yield(Test::Unit::TestCase::STARTED, name)
 
-        @_result = result
+          @_result = result
 
-        serialized = run_in_isolation do |proxy|
-          begin
-            super(proxy) { }
-          rescue Exception => e
-            proxy.add_error(Test::Unit::Error.new(name, e))
+          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)
+          _run_class_setup
 
-        proxy = Marshal.load(serialized)
-        proxy.__replay__(@_result)
+          serialized = run_in_isolation do |isolated_runner|
+            super(isolated_runner)
+          end
 
-        yield(Test::Unit::TestCase::FINISHED, name)
+          retval, proxy = Marshal.load(serialized)
+          proxy.__replay__(runner)
+          retval
+        end
       end
 
       module Forking
@@ -52,8 +97,8 @@ module ActiveSupport
           pid = fork do
             read.close
             proxy = ProxyTestResult.new
-            yield proxy
-            write.puts [Marshal.dump(proxy)].pack("m")
+            retval = yield proxy
+            write.puts [Marshal.dump([retval, proxy])].pack("m")
             exit!
           end
 
@@ -65,6 +110,8 @@ module ActiveSupport
       end
 
       module Subprocess
+        ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
+
         # Crazy H4X to get this working in windows / jruby with
         # no forking.
         def run_in_isolation(&blk)
@@ -72,9 +119,9 @@ module ActiveSupport
 
           if ENV["ISOLATION_TEST"]
             proxy = ProxyTestResult.new
-            yield proxy
+            retval = yield proxy
             File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-              file.puts [Marshal.dump(proxy)].pack("m")
+              file.puts [Marshal.dump([retval, proxy])].pack("m")
             end
             exit!
           else