activesupport 2.3.5 → 3.0.0.beta3

data/lib/active_support/notifications/fanout.rb

@@ -0,0 +1,83 @@
+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 bind(pattern)
+        Binding.new(self, pattern)
+      end
+
+      def subscribe(pattern = nil, &block)
+        @listeners_for.clear
+        @subscribers << Subscriber.new(pattern, &block)
+        @subscribers.last
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.delete(subscriber)
+        @listeners_for.clear
+      end
+
+      def publish(name, *args)
+        if listeners = @listeners_for[name]
+          listeners.each { |s| s.publish(name, *args) }
+        else
+          @listeners_for[name] = @subscribers.select { |s| s.publish(name, *args) }
+        end
+      end
+
+      # This is a sync queue, so there is not waiting.
+      def wait
+      end
+
+      # Used for internal implementation only.
+      class Binding #:nodoc:
+        def initialize(queue, pattern)
+          @queue = queue
+          @pattern =
+            case pattern
+            when Regexp, NilClass
+              pattern
+            else
+              /^#{Regexp.escape(pattern.to_s)}$/
+            end
+        end
+
+        def subscribe(&block)
+          @queue.subscribe(@pattern, &block)
+        end
+      end
+
+      class Subscriber #:nodoc:
+        def initialize(pattern, &block)
+          @pattern = pattern
+          @block = block
+        end
+
+        def publish(*args)
+          return unless matches?(args.first)
+          push(*args)
+          true
+        end
+
+        def drained?
+          true
+        end
+
+        private
+          def matches?(name)
+            !@pattern || @pattern =~ name.to_s
+          end
+
+          def push(*args)
+            @block.call(*args)
+          end
+      end
+    end
+  end
+end

data/lib/active_support/notifications/instrumenter.rb

@@ -0,0 +1,50 @@
+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.
+      def instrument(name, payload={})
+        time = Time.now
+        result = yield(payload) if block_given?
+        @notifier.publish(name, time, Time.now, @id, payload)
+        result
+      end
+
+      private
+        def unique_id
+          SecureRandom.hex(10)
+        end
+    end
+
+    class Event
+      attr_reader :name, :time, :end, :transaction_id, :payload
+
+      def initialize(name, start, ending, transaction_id, payload)
+        @name           = name
+        @payload        = payload.dup
+        @time           = start
+        @transaction_id = transaction_id
+        @end            = ending
+      end
+
+      def duration
+        @duration ||= 1000.0 * (@end - @time)
+      end
+
+      def parent_of?(event)
+        start = (self.time - event.time) * 1000
+        start <= 0 && (start + duration >= event.duration)
+      end
+    end
+  end
+end

data/lib/active_support/notifications.rb

@@ -0,0 +1,81 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActiveSupport
+  # Notifications provides an instrumentation API for Ruby. To instrument an
+  # action in Ruby you just need to do:
+  #
+  #   ActiveSupport::Notifications.instrument(:render, :extra => :information) do
+  #     render :text => "Foo"
+  #   end
+  #
+  # You can consume those events and the information they provide by registering
+  # a log subscriber. For instance, let's store all instrumented events in an array:
+  #
+  #   @events = []
+  #
+  #   ActiveSupport::Notifications.subscribe do |*args|
+  #     @events << ActiveSupport::Notifications::Event.new(*args)
+  #   end
+  #
+  #   ActiveSupport::Notifications.instrument(:render, :extra => :information) do
+  #     render :text => "Foo"
+  #   end
+  #
+  #   event = @events.first
+  #   event.name      #=> :render
+  #   event.duration  #=> 10 (in miliseconds)
+  #   event.result    #=> "Foo"
+  #   event.payload   #=> { :extra => :information }
+  #
+  # When subscribing to Notifications, you can pass a pattern, to only consume
+  # events that match the pattern:
+  #
+  #   ActiveSupport::Notifications.subscribe(/render/) do |event|
+  #     @render_events << event
+  #   end
+  #
+  # Notifications ships with a queue implementation that consumes and publish events
+  # to log subscribers in a thread. You can use any queue implementation you want.
+  #
+  module Notifications
+    autoload :Instrumenter, 'active_support/notifications/instrumenter'
+    autoload :Event, 'active_support/notifications/instrumenter'
+    autoload :Fanout, 'active_support/notifications/fanout'
+
+    class << self
+      attr_writer :notifier
+      delegate :publish, :subscribe, :unsubscribe, :to => :notifier
+      delegate :instrument, :to => :instrumenter
+
+      def notifier
+        @notifier ||= Notifier.new
+      end
+
+      def instrumenter
+        Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
+      end
+    end
+
+    class Notifier
+      def initialize(queue = Fanout.new)
+        @queue = queue
+      end
+
+      def publish(*args)
+        @queue.publish(*args)
+      end
+
+      def subscribe(pattern = nil, &block)
+        @queue.bind(pattern).subscribe(&block)
+      end
+
+      def unsubscribe(subscriber)
+        @queue.unsubscribe(subscriber)
+      end
+
+      def wait
+        @queue.wait
+      end
+    end
+  end
+end

data/lib/active_support/option_merger.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/deep_merge'
+
 module ActiveSupport
   class OptionMerger #:nodoc:
     instance_methods.each do |method|

data/lib/active_support/ordered_hash.rb

@@ -1,10 +1,28 @@
+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'
       def initialize(*args, &block)
         super
         @keys = []
@@ -52,7 +70,7 @@ module ActiveSupport
         end
         super
       end
-      
+
       def delete_if
         super
         sync_keys!
@@ -131,11 +149,10 @@ module ActiveSupport
         "#<OrderedHash #{super}>"
       end
 
-    private
-
-      def sync_keys!
-        @keys.delete_if {|k| !has_key?(k)}
-      end
+      private
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
+        end
     end
   end
 end

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
@@ -16,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,64 @@
+require "active_support"
+require "rails"
+
+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
+
+    # 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
+    config.i18n = ActiveSupport::OrderedOptions.new
+    config.i18n.railties_load_path = []
+    config.i18n.load_path = []
+
+    initializer "i18n.initialize" do
+      ActiveSupport.on_load(:i18n) do
+        I18n.reload!
+
+        ActionDispatch::Callbacks.to_prepare do
+          I18n.reload!
+        end
+      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 :railties_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,21 @@
+# 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'
+require 'active_support/core_ext/file/path'
+require 'active_support/core_ext/module/method_names'

data/lib/active_support/test_case.rb

@@ -3,10 +3,12 @@ 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'
+require 'active_support/core_ext/kernel/reporting'
 
 begin
-  gem 'mocha', ">= 0.9.7"
-  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
@@ -20,21 +22,21 @@ 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'
       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,6 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/blank'
+
 module ActiveSupport
   module Testing
     module Assertions
@@ -60,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

@@ -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