activesupport 3.0.0.rc → 3.0.0.rc2

data/lib/active_support/core_ext/string/inflections.rb

@@ -1,3 +1,5 @@
+require 'active_support/inflector/methods'
+require 'active_support/inflector/inflections'
 # String inflections define new methods on the String class to transform names for different purposes.
 # For instance, you can figure out the name of a database from the name of a class.
 #
@@ -70,7 +72,7 @@ class String
   alias_method :titlecase, :titleize
 
   # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-  # 
+  #
   # +underscore+ will also change '::' to '/' to convert namespaces to paths.
   #
   #   "ActiveRecord".underscore         # => "active_record"
@@ -95,7 +97,7 @@ class String
   end
 
   # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
-  # 
+  #
   # ==== Examples
   #
   #   class Person
@@ -103,10 +105,10 @@ class String
   #       "#{id}-#{name.parameterize}"
   #     end
   #   end
-  # 
+  #
   #   @person = Person.find(1)
   #   # => #<Person id: 1, name: "Donald E. Knuth">
-  # 
+  #
   #   <%= link_to(@person.name, person_path %>
   #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
   def parameterize(sep = '-')
@@ -136,11 +138,11 @@ class String
   def classify
     ActiveSupport::Inflector.classify(self)
   end
-  
+
   # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
   # Like +titleize+, this is meant for creating pretty output.
   #
-  #   "employee_salary" # => "Employee salary" 
+  #   "employee_salary" # => "Employee salary"
   #   "author_id"       # => "Author"
   def humanize
     ActiveSupport::Inflector.humanize(self)

data/lib/active_support/core_ext/string/multibyte.rb

@@ -12,11 +12,11 @@ class String
     # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsuled string.
     #
     #   name = 'Claus Müller'
-    #   name.reverse  #=> "rell??M sualC"
-    #   name.length   #=> 13
+    #   name.reverse # => "rell??M sualC"
+    #   name.length  # => 13
     #
-    #   name.mb_chars.reverse.to_s   #=> "rellüM sualC"
-    #   name.mb_chars.length         #=> 12
+    #   name.mb_chars.reverse.to_s # => "rellüM sualC"
+    #   name.mb_chars.length       # => 12
     #
     # In Ruby 1.9 and newer +mb_chars+ returns +self+ because String is (mostly) encoding aware. This means that
     # it becomes easy to run one version of your code on multiple Ruby versions.
@@ -26,7 +26,7 @@ class String
     # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
     # method chaining on the result of any of these methods.
     #
-    #   name.mb_chars.reverse.length #=> 12
+    #   name.mb_chars.reverse.length # => 12
     #
     # == Interoperability and configuration
     #

data/lib/active_support/core_ext/time/calculations.rb

@@ -92,12 +92,12 @@ class Time
       options[:weeks], partial_weeks = options[:weeks].divmod(1)
       options[:days] = (options[:days] || 0) + 7 * partial_weeks
     end
-    
+
     unless options[:days].nil?
       options[:days], partial_days = options[:days].divmod(1)
       options[:hours] = (options[:hours] || 0) + 24 * partial_days
     end
-    
+
     d = to_date.advance(options)
     time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
     seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600

data/lib/active_support/core_ext/time/conversions.rb

@@ -46,7 +46,7 @@ class Time
   end
   alias_method :to_default_s, :to_s
   alias_method :to_s, :to_formatted_s
- 
+
   # Returns the UTC offset as an +HH:MM formatted string.
   #
   #   Time.local(2000).formatted_offset         # => "-06:00"

data/lib/active_support/core_ext/time/zones.rb

@@ -4,13 +4,13 @@ class Time
   class << self
     attr_accessor :zone_default
 
-    # Returns the TimeZone for the current request, if this has been set (via Time.zone=). 
+    # Returns the TimeZone for the current request, if this has been set (via Time.zone=).
     # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
     def zone
       Thread.current[:time_zone] || zone_default
     end
 
-    # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread. 
+    # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread.
     #
     # This method accepts any of the following:
     #
@@ -63,7 +63,7 @@ class Time
   # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt> as the local zone
   # instead of the operating system's time zone.
   #
-  # You can also pass in a TimeZone instance or string that identifies a TimeZone as an argument, 
+  # You can also pass in a TimeZone instance or string that identifies a TimeZone as an argument,
   # and the conversion will be based on that zone instead of <tt>Time.zone</tt>.
   #
   #   Time.utc(2000).in_time_zone('Alaska')  # => Fri, 31 Dec 1999 15:00:00 AKST -09:00

data/lib/active_support/dependencies.rb

@@ -63,58 +63,78 @@ module ActiveSupport #:nodoc:
     mattr_accessor :log_activity
     self.log_activity = false
 
-    class WatchStack < Array
+    # The WatchStack keeps a stack of the modules being watched as files are loaded.
+    # If a file in the process of being loaded (parent.rb) triggers the load of 
+    # another file (child.rb) the stack will ensure that child.rb handles the new 
+    # constants.
+    #
+    # If child.rb is being autoloaded, its constants will be added to
+    # autoloaded_constants. If it was being `require`d, they will be discarded.
+    #
+    # This is handled by walking back up the watch stack and adding the constants
+    # found by child.rb to the list of original constants in parent.rb
+    class WatchStack < Hash
+      # @watching is a stack of lists of constants being watched. For instance,
+      # if parent.rb is autoloaded, the stack will look like [[Object]]. If parent.rb
+      # then requires namespace/child.rb, the stack will look like [[Object], [Namespace]].
+
       def initialize
-        @mutex = Mutex.new
+        @watching = []
+        super { |h,k| h[k] = [] }
       end
 
-      def self.locked(*methods)
-        methods.each { |m| class_eval "def #{m}(*) lock { super } end", __FILE__, __LINE__ }
-      end
+      # return a list of new constants found since the last call to watch_modules
+      def new_constants
+        constants = []
 
-      locked :concat, :each, :delete_if, :<<
+        # Grab the list of namespaces that we're looking for new constants under
+        @watching.last.each do |namespace|
+          # Retrieve the constants that were present under the namespace when watch_modules
+          # was originally called
+          original_constants = self[namespace].last
 
-      def new_constants_for(frames)
-        constants = []
-        frames.each do |mod_name, prior_constants|
-          mod = Inflector.constantize(mod_name) if Dependencies.qualified_const_defined?(mod_name)
+          mod = Inflector.constantize(namespace) if Dependencies.qualified_const_defined?(namespace)
           next unless mod.is_a?(Module)
 
-          new_constants = mod.local_constant_names - prior_constants
-
-          # If we are checking for constants under, say, :Object, nested under something
-          # else that is checking for constants also under :Object, make sure the
-          # parent knows that we have found, and taken care of, the constant.
-          #
-          # In particular, this means that since Kernel.require discards the constants
-          # it finds, parents will be notified that about those constants, and not
-          # consider them "new". As a result, they will not be added to the
-          # autoloaded_constants list.
-          each do |key, value|
-            value.concat(new_constants) if key == mod_name
+          # Get a list of the constants that were added
+          new_constants = mod.local_constant_names - original_constants
+
+          # self[namespace] returns an Array of the constants that are being evaluated
+          # for that namespace. For instance, if parent.rb requires child.rb, the first
+          # element of self[Object] will be an Array of the constants that were present
+          # before parent.rb was required. The second element will be an Array of the
+          # constants that were present before child.rb was required.
+          self[namespace].each do |namespace_constants|
+            namespace_constants.concat(new_constants)
           end
 
+          # Normalize the list of new constants, and add them to the list we will return
           new_constants.each do |suffix|
-            constants << ([mod_name, suffix] - ["Object"]).join("::")
+            constants << ([namespace, suffix] - ["Object"]).join("::")
           end
         end
         constants
+      ensure
+        # A call to new_constants is always called after a call to watch_modules
+        pop_modules(@watching.pop)
       end
 
       # Add a set of modules to the watch stack, remembering the initial constants
-      def add_modules(modules)
-        list = modules.map do |desc|
-          name = Dependencies.to_constant_name(desc)
-          consts = Dependencies.qualified_const_defined?(name) ?
-            Inflector.constantize(name).local_constant_names : []
-          [name, consts]
+      def watch_namespaces(namespaces)
+        watching = []
+        namespaces.map do |namespace|
+          module_name = Dependencies.to_constant_name(namespace)
+          original_constants = Dependencies.qualified_const_defined?(module_name) ?
+            Inflector.constantize(module_name).local_constant_names : []
+
+          watching << module_name
+          self[module_name] << original_constants
         end
-        concat(list)
-        list
+        @watching << watching
       end
 
-      def lock
-        @mutex.synchronize { yield self }
+      def pop_modules(modules)
+        modules.each { |mod| self[mod].pop }
       end
     end
 
@@ -563,14 +583,15 @@ module ActiveSupport #:nodoc:
     # and will be removed immediately.
     def new_constants_in(*descs)
       log_call(*descs)
-      watch_frames = constant_watch_stack.add_modules(descs)
 
+      constant_watch_stack.watch_namespaces(descs)
       aborting = true
+
       begin
         yield # Now yield to the code that is to define new constants.
         aborting = false
       ensure
-        new_constants = constant_watch_stack.new_constants_for(watch_frames)
+        new_constants = constant_watch_stack.new_constants
 
         log "New constants: #{new_constants * ', '}"
         return new_constants unless aborting
@@ -580,9 +601,6 @@ module ActiveSupport #:nodoc:
       end
 
       return []
-    ensure
-      # Remove the stack frames that we added.
-      watch_frames.each {|f| constant_watch_stack.delete(f) } if watch_frames.present?
     end
 
     class LoadingModule #:nodoc:

data/lib/active_support/duration.rb

@@ -3,7 +3,7 @@ require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/object/acts_like'
 
 module ActiveSupport
-  # Provides accurate date and time measurements using Date#advance and 
+  # Provides accurate date and time measurements using Date#advance and
   # Time#advance, respectively. It mainly supports the methods on Numeric.
   # Example:
   #

data/lib/active_support/hash_with_indifferent_access.rb

@@ -27,6 +27,12 @@ module ActiveSupport
       end
     end
 
+    def self.new_from_hash_copying_default(hash)
+      ActiveSupport::HashWithIndifferentAccess.new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
     alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
     alias_method :regular_update, :update unless method_defined?(:regular_update)
 
@@ -101,7 +107,7 @@ module ActiveSupport
     # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
     # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
     def reverse_merge(other_hash)
-      super other_hash.with_indifferent_access
+      super self.class.new_from_hash_copying_default(other_hash)
     end
 
     def reverse_merge!(other_hash)
@@ -132,9 +138,9 @@ module ActiveSupport
       def convert_value(value)
         case value
         when Hash
-          value.with_indifferent_access
+          self.class.new_from_hash_copying_default(value)
         when Array
-          value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+          value.collect { |e| e.is_a?(Hash) ? self.class.new_from_hash_copying_default(e) : e }
         else
           value
         end

data/lib/active_support/i18n_railtie.rb

@@ -66,7 +66,7 @@ module I18n
 
       I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
     end
-  
+
     def self.validate_fallbacks(fallbacks)
       case fallbacks
       when ActiveSupport::OrderedOptions

data/lib/active_support/lazy_load_hooks.rb

@@ -1,3 +1,22 @@
+# lazy_load_hooks allows rails to lazily load a lot of components and thus making the app boot faster. Because of
+# this feature now there is no need to require <tt>ActiveRecord::Base</tt> at boot time purely to apply configuration. Instead
+# a hook is registered that applies configuration once <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is used
+# as example but this feature can be applied elsewhere too.
+#
+# Here is an example where +on_load+ method is called to register a hook.
+#
+#  initializer "active_record.initialize_timezone" do
+#    ActiveSupport.on_load(:active_record) do
+#      self.time_zone_aware_attributes = true
+#      self.default_timezone = :utc
+#    end
+#  end
+#
+# When the entirety of +activerecord/lib/active_record/base.rb+ has been evaluated then +run_load_hooks+ is invoked.
+# The very last line of +activerecord/lib/active_record/base.rb+ is:
+#
+#  ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+#
 module ActiveSupport
   @load_hooks = Hash.new {|h,k| h[k] = [] }
   @loaded = {}
@@ -24,4 +43,4 @@ module ActiveSupport
       execute_hook(base, options, hook)
     end
   end
-end
+end

data/lib/active_support/locale/en.yml

@@ -7,10 +7,10 @@ en:
       default: "%Y-%m-%d"
       short: "%b %d"
       long: "%B %d, %Y"
-      
+
     day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
     abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
-      
+
     # Don't forget the nil at the beginning; there's no such thing as a 0th month
     month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
     abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
@@ -27,7 +27,7 @@ en:
       long: "%B %d, %Y %H:%M"
     am: "am"
     pm: "pm"
-      
+
 # Used in array.to_sentence.
   support:
     array:

data/lib/active_support/log_subscriber.rb

@@ -31,23 +31,10 @@ module ActiveSupport
   # all logs when the request finishes (via action_dispatch.callback notification) in
   # a Rails environment.
   class LogSubscriber
-    mattr_accessor :colorize_logging
-    self.colorize_logging = true
-
-    class_attribute :logger
-
-    class << self
-      remove_method :logger
-    end
-
-    def self.logger
-      @logger ||= Rails.logger if defined?(Rails)
-    end
-
     # Embed in a String to clear all previous ANSI sequences.
     CLEAR   = "\e[0m"
     BOLD    = "\e[1m"
-            
+
     # Colors
     BLACK   = "\e[30m"
     RED     = "\e[31m"
@@ -58,32 +45,44 @@ module ActiveSupport
     CYAN    = "\e[36m"
     WHITE   = "\e[37m"
 
-    def self.attach_to(namespace, log_subscriber=new, notifier=ActiveSupport::Notifications)
-      log_subscribers << log_subscriber
-      @@flushable_loggers = nil
+    mattr_accessor :colorize_logging
+    self.colorize_logging = true
+
+    class_attribute :logger
+
+    class << self
+      remove_method :logger
+      def logger
+        @logger ||= Rails.logger if defined?(Rails)
+      end
+
+      def attach_to(namespace, log_subscriber=new, notifier=ActiveSupport::Notifications)
+        log_subscribers << log_subscriber
+        @@flushable_loggers = nil
 
-      log_subscriber.public_methods(false).each do |event|
-        next if 'call' == event.to_s
+        log_subscriber.public_methods(false).each do |event|
+          next if 'call' == event.to_s
 
-        notifier.subscribe("#{event}.#{namespace}", log_subscriber)
+          notifier.subscribe("#{event}.#{namespace}", log_subscriber)
+        end
       end
-    end
 
-    def self.log_subscribers
-      @@log_subscribers ||= []
-    end
+      def log_subscribers
+        @@log_subscribers ||= []
+      end
 
-    def self.flushable_loggers
-      @@flushable_loggers ||= begin
-        loggers = log_subscribers.map(&:logger)
-        loggers.uniq!
-        loggers.select { |l| l.respond_to?(:flush) }
+      def flushable_loggers
+        @@flushable_loggers ||= begin
+          loggers = log_subscribers.map(&:logger)
+          loggers.uniq!
+          loggers.select { |l| l.respond_to?(:flush) }
+        end
       end
-    end
 
-    # Flush all log_subscribers' logger.
-    def self.flush_all!
-      flushable_loggers.each(&:flush)
+      # Flush all log_subscribers' logger.
+      def flush_all!
+        flushable_loggers.each(&:flush)
+      end
     end
 
     def call(message, *args)