activesupport 3.2.22.5 → 4.0.0

data/lib/active_support/ordered_hash.rb

@@ -1,8 +1,3 @@
-begin
-  require 'psych'
-rescue LoadError
-end
-
 require 'yaml'
 
 YAML.add_builtin_type("omap") do |type, val|
@@ -10,16 +5,20 @@ YAML.add_builtin_type("omap") do |type, val|
 end
 
 module ActiveSupport
-  # The order of iteration over hashes in Ruby 1.8 is undefined. For example, you do not know the
-  # order in which +keys+ will return keys, or +each+ yield pairs. <tt>ActiveSupport::OrderedHash</tt>
-  # implements a hash that preserves insertion order, as in Ruby 1.9:
+  # <tt>ActiveSupport::OrderedHash</tt> implements a hash that preserves
+  # insertion order.
   #
   #   oh = ActiveSupport::OrderedHash.new
   #   oh[:a] = 1
   #   oh[:b] = 2
   #   oh.keys # => [:a, :b], this order is guaranteed
   #
-  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts with other implementations.
+  # Also, maps the +omap+ feature for YAML files
+  # (See http://yaml.org/type/omap.html) to support ordered items
+  # when loading from yaml.
+  #
+  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts
+  # with other implementations.
   class OrderedHash < ::Hash
     def to_yaml_type
       "!tag:yaml.org,2002:omap"
@@ -29,20 +28,6 @@ module ActiveSupport
       coder.represent_seq '!omap', map { |k,v| { k => v } }
     end
 
-    def to_yaml(opts = {})
-      if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
-        return super
-      end
-
-      YAML.quick_emit(self, opts) do |out|
-        out.seq(taguri) do |seq|
-          each do |k, v|
-            seq.add(k => v)
-          end
-        end
-      end
-    end
-
     def nested_under_indifferent_access
       self
     end
@@ -51,172 +36,5 @@ module ActiveSupport
     def extractable_options?
       true
     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 = []
-      end
-
-      def self.[](*args)
-        ordered_hash = new
-
-        if (args.length == 1 && args.first.is_a?(Array))
-          args.first.each do |key_value_pair|
-            next unless (key_value_pair.is_a?(Array))
-            ordered_hash[key_value_pair[0]] = key_value_pair[1]
-          end
-
-          return ordered_hash
-        end
-
-        unless (args.size % 2 == 0)
-          raise ArgumentError.new("odd number of arguments for Hash")
-        end
-
-        args.each_with_index do |val, ind|
-          next if (ind % 2 != 0)
-          ordered_hash[val] = args[ind + 1]
-        end
-
-        ordered_hash
-      end
-
-      def initialize_copy(other)
-        super
-        # make a deep copy of keys
-        @keys = other.keys
-      end
-
-      def []=(key, value)
-        @keys << key unless has_key?(key)
-        super
-      end
-
-      def delete(key)
-        if has_key? key
-          index = @keys.index(key)
-          @keys.delete_at index
-        end
-        super
-      end
-
-      def delete_if
-        super
-        sync_keys!
-        self
-      end
-
-      def reject!
-        super
-        sync_keys!
-        self
-      end
-
-      def reject(&block)
-        dup.reject!(&block)
-      end
-
-      def keys
-        @keys.dup
-      end
-
-      def values
-        @keys.collect { |key| self[key] }
-      end
-
-      def to_hash
-        self
-      end
-
-      def to_a
-        @keys.map { |key| [ key, self[key] ] }
-      end
-
-      def each_key
-        return to_enum(:each_key) unless block_given?
-        @keys.each { |key| yield key }
-        self
-      end
-
-      def each_value
-        return to_enum(:each_value) unless block_given?
-        @keys.each { |key| yield self[key]}
-        self
-      end
-
-      def each
-        return to_enum(:each) unless block_given?
-        @keys.each {|key| yield [key, self[key]]}
-        self
-      end
-
-      def each_pair
-        return to_enum(:each_pair) unless block_given?
-        @keys.each {|key| yield key, self[key]}
-        self
-      end
-
-      alias_method :select, :find_all
-
-      def clear
-        super
-        @keys.clear
-        self
-      end
-
-      def shift
-        k = @keys.first
-        v = delete(k)
-        [k, v]
-      end
-
-      def merge!(other_hash)
-        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
-
-      alias_method :update, :merge!
-
-      def merge(other_hash, &block)
-        dup.merge!(other_hash, &block)
-      end
-
-      # 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
-
-      def invert
-        OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
-      end
-
-      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

@@ -1,23 +1,20 @@
-require 'active_support/ordered_hash'
-
-# Usually key value pairs are handled something like this:
-#
-#   h = {}
-#   h[:boy] = 'John'
-#   h[:girl] = 'Mary'
-#   h[:boy]  # => 'John'
-#   h[:girl] # => 'Mary'
-#
-# Using <tt>OrderedOptions</tt>, the above code could be reduced to:
-#
-#   h = ActiveSupport::OrderedOptions.new
-#   h.boy = 'John'
-#   h.girl = 'Mary'
-#   h.boy  # => 'John'
-#   h.girl # => 'Mary'
-#
-module ActiveSupport #:nodoc:
-  class OrderedOptions < OrderedHash
+module ActiveSupport
+  # Usually key value pairs are handled something like this:
+  #
+  #   h = {}
+  #   h[:boy] = 'John'
+  #   h[:girl] = 'Mary'
+  #   h[:boy]  # => 'John'
+  #   h[:girl] # => 'Mary'
+  #
+  # Using +OrderedOptions+, the above code could be reduced to:
+  #
+  #   h = ActiveSupport::OrderedOptions.new
+  #   h.boy = 'John'
+  #   h.girl = 'Mary'
+  #   h.boy  # => 'John'
+  #   h.girl # => 'Mary'
+  class OrderedOptions < Hash
     alias_method :_get, :[] # preserve the original #[] method
     protected :_get # make it protected
 
@@ -30,14 +27,15 @@ module ActiveSupport #:nodoc:
     end
 
     def method_missing(name, *args)
-      if name.to_s =~ /(.*)=$/
-        self[$1] = args.first
+      name_string = name.to_s
+      if name_string.chomp!('=')
+        self[name_string] = args.first
       else
         self[name]
       end
     end
 
-    def respond_to?(name)
+    def respond_to_missing?(name, include_private)
       true
     end
   end

data/lib/active_support/per_thread_registry.rb

@@ -0,0 +1,52 @@
+module ActiveSupport
+  # This module is used to encapsulate access to thread local variables.
+  #
+  # Instead of polluting the thread locals namespace:
+  #
+  #   Thread.current[:connection_handler]
+  #
+  # you define a class that extends this module:
+  #
+  #   module ActiveRecord
+  #     class RuntimeRegistry
+  #       extend ActiveSupport::PerThreadRegistry
+  #
+  #       attr_accessor :connection_handler
+  #     end
+  #   end
+  #
+  # and invoke the declared instance accessors as class methods. So
+  #
+  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
+  #
+  # sets a connection handler local to the current thread, and
+  #
+  #   ActiveRecord::RuntimeRegistry.connection_handler
+  #
+  # returns a connection handler local to the current thread.
+  #
+  # This feature is accomplished by instantiating the class and storing the
+  # instance as a thread local keyed by the class name. In the example above
+  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
+  # The class methods proxy to said thread local instance.
+  #
+  # If the class has an initializer, it must accept no arguments.
+  module PerThreadRegistry
+    protected
+
+      def method_missing(name, *args, &block) # :nodoc:
+        # Caches the method definition as a singleton method of the receiver.
+        define_singleton_method(name) do |*a, &b|
+          per_thread_registry_instance.public_send(name, *a, &b)
+        end
+
+        send(name, *args, &block)
+      end
+
+    private
+
+      def per_thread_registry_instance
+        Thread.current[name] ||= new
+      end
+  end
+end

data/lib/active_support/proxy_object.rb

@@ -0,0 +1,13 @@
+module ActiveSupport
+  # A class with no predefined methods that behaves similarly to Builder's
+  # BlankSlate. Used for proxy classes.
+  class ProxyObject < ::BasicObject
+    undef_method :==
+    undef_method :equal?
+
+    # Let ActiveSupport::ProxyObject at least raise exceptions.
+    def raise(*args)
+      ::Object.send(:raise, *args)
+    end
+  end
+end

data/lib/active_support/rails.rb

@@ -0,0 +1,27 @@
+# This is private interface.
+#
+# Rails components cherry pick from Active Support as needed, but there are a
+# few features that are used for sure some way or another and it is not worth
+# to put individual requires absolutely everywhere. Think blank? for example.
+#
+# This file is loaded by every Rails component except Active Support itself,
+# but it does not belong to the Rails public interface. It is internal to
+# Rails and can change anytime.
+
+# Defines Object#blank? and Object#present?.
+require 'active_support/core_ext/object/blank'
+
+# Rails own autoload, eager_load, etc.
+require 'active_support/dependencies/autoload'
+
+# Support for ClassMethods and the included macro.
+require 'active_support/concern'
+
+# Defines Class#class_attribute.
+require 'active_support/core_ext/class/attribute'
+
+# Defines Module#delegate.
+require 'active_support/core_ext/module/delegation'
+
+# Defines ActiveSupport::Deprecation.
+require 'active_support/deprecation'

data/lib/active_support/railtie.rb

@@ -2,42 +2,14 @@ require "active_support"
 require "active_support/i18n_railtie"
 
 module ActiveSupport
-  class Railtie < Rails::Railtie
+  class Railtie < Rails::Railtie # :nodoc:
     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
+    config.eager_load_namespaces << ActiveSupport
 
     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
 
@@ -48,14 +20,22 @@ module ActiveSupport
       zone_default = Time.find_zone!(app.config.time_zone)
 
       unless zone_default
-        raise \
-          'Value assigned to config.time_zone not recognized.' +
+        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
 
+    # Sets the default week start
+    # If assigned value is not a valid day symbol (e.g. :sunday, :monday, ...), an exception will be raised.
+    initializer "active_support.initialize_beginning_of_week" do |app|
+      require 'active_support/core_ext/date/calculations'
+      beginning_of_week_default = Date.find_beginning_of_week!(app.config.beginning_of_week)
+
+      Date.beginning_of_week_default = beginning_of_week_default
+    end
+
     initializer "active_support.set_configs" do |app|
       app.config.active_support.each do |k, v|
         k = "#{k}="

data/lib/active_support/rescuable.rb

@@ -31,11 +31,11 @@ module ActiveSupport
       # any.
       #
       #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, :with => :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, :with => :show_errors
+      #     rescue_from User::NotAuthorized, with: :deny_access # self defined exception
+      #     rescue_from ActiveRecord::RecordInvalid, with: :show_errors
       #
       #     rescue_from 'MyAppError::Base' do |exception|
-      #       render :xml => exception, :status => 500
+      #       render xml: exception, status: 500
       #     end
       #
       #     protected
@@ -48,6 +48,7 @@ module ActiveSupport
       #       end
       #   end
       #
+      # Exceptions raised inside exception handlers are not propagated up.
       def rescue_from(*klasses, &block)
         options = klasses.extract_options!
 
@@ -108,7 +109,11 @@ module ActiveSupport
       when Symbol
         method(rescuer)
       when Proc
-        rescuer.bind(self)
+        if rescuer.arity == 0
+          Proc.new { instance_exec(&rescuer) }
+        else
+          Proc.new { |_exception| instance_exec(_exception, &rescuer) }
+        end
       end
     end
   end

data/lib/active_support/string_inquirer.rb

@@ -3,19 +3,24 @@ module ActiveSupport
   # for equality. The value returned by <tt>Rails.env</tt> is wrapped
   # in a StringInquirer object so instead of calling this:
   #
-  #   Rails.env == "production"
+  #   Rails.env == 'production'
   #
   # you can call this:
   #
   #   Rails.env.production?
-  #
   class StringInquirer < String
-    def method_missing(method_name, *arguments)
-      if method_name.to_s[-1,1] == "?"
-        self == method_name.to_s[0..-2]
-      else
-        super
+    private
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name[-1] == '?'
+      end
+
+      def method_missing(method_name, *arguments)
+        if method_name[-1] == '?'
+          self == method_name[0..-2]
+        else
+          super
+        end
       end
-    end
   end
 end

data/lib/active_support/subscriber.rb

@@ -0,0 +1,93 @@
+require 'active_support/per_thread_registry'
+
+module ActiveSupport
+  # ActiveSupport::Subscriber is an object set to consume
+  # ActiveSupport::Notifications. The subscriber dispatches notifications to
+  # a registered object based on its given namespace.
+  #
+  # An example would be Active Record subscriber responsible for collecting
+  # statistics about queries:
+  #
+  #   module ActiveRecord
+  #     class StatsSubscriber < ActiveSupport::Subscriber
+  #       def sql(event)
+  #         Statsd.timing("sql.#{event.payload[:name]}", event.duration)
+  #       end
+  #     end
+  #   end
+  #
+  # And it's finally registered as:
+  #
+  #   ActiveRecord::StatsSubscriber.attach_to :active_record
+  #
+  # Since we need to know all instance methods before attaching the log
+  # subscriber, the line above should be called after your subscriber definition.
+  #
+  # After configured, whenever a "sql.active_record" notification is published,
+  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
+  # the +sql+ method.
+  class Subscriber
+    class << self
+
+      # Attach the subscriber to a namespace.
+      def attach_to(namespace, subscriber=new, notifier=ActiveSupport::Notifications)
+        subscribers << subscriber
+
+        subscriber.public_methods(false).each do |event|
+          next if %w{ start finish }.include?(event.to_s)
+
+          notifier.subscribe("#{event}.#{namespace}", subscriber)
+        end
+      end
+
+      def subscribers
+        @@subscribers ||= []
+      end
+    end
+
+    def initialize
+      @queue_key = [self.class.name, object_id].join "-"
+      super
+    end
+
+    def start(name, id, payload)
+      e = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
+      parent = event_stack.last
+      parent << e if parent
+
+      event_stack.push e
+    end
+
+    def finish(name, id, payload)
+      finished  = Time.now
+      event     = event_stack.pop
+      event.end = finished
+      event.payload.merge!(payload)
+
+      method = name.split('.').first
+      send(method, event)
+    end
+
+    private
+
+      def event_stack
+        SubscriberQueueRegistry.get_queue(@queue_key)
+      end
+  end
+
+  # This is a registry for all the event stacks kept for subscribers.
+  #
+  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
+  # for further details.
+  class SubscriberQueueRegistry # :nodoc:
+    extend PerThreadRegistry
+
+    def initialize
+      @registry = {}
+    end
+
+    def get_queue(queue_key)
+      @registry[queue_key] ||= []
+    end
+  end
+end