activesupport 2.1.2 → 2.2.2

data/lib/active_support/core_ext/hash.rb

@@ -1,10 +1,11 @@
-%w(keys indifferent_access reverse_merge conversions diff slice except).each do |ext|
+%w(keys indifferent_access deep_merge reverse_merge conversions diff slice except).each do |ext|
   require "active_support/core_ext/hash/#{ext}"
 end
 
 class Hash #:nodoc:
   include ActiveSupport::CoreExtensions::Hash::Keys
   include ActiveSupport::CoreExtensions::Hash::IndifferentAccess
+  include ActiveSupport::CoreExtensions::Hash::DeepMerge
   include ActiveSupport::CoreExtensions::Hash::ReverseMerge
   include ActiveSupport::CoreExtensions::Hash::Conversions
   include ActiveSupport::CoreExtensions::Hash::Diff

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

@@ -156,7 +156,7 @@ module ActiveSupport #:nodoc:
                       XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
                       attributes
                     )
-                end
+                  end
               end
             end
             

data/lib/active_support/core_ext/hash/deep_merge.rb

@@ -0,0 +1,23 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      # Allows for deep merging
+      module DeepMerge
+        # Returns a new hash with +self+ and +other_hash+ merged recursively.
+        def deep_merge(other_hash)
+          self.merge(other_hash) do |key, oldval, newval|
+            oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+            newval = newval.to_hash if newval.respond_to?(:to_hash)
+            oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? oldval.deep_merge(newval) : newval
+          end
+        end
+
+        # Returns a new hash with +self+ and +other_hash+ merged recursively.
+        # Modifies the receiver in place.
+        def deep_merge!(other_hash)
+          replace(deep_merge(other_hash))
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/hash/except.rb

@@ -13,7 +13,7 @@ module ActiveSupport #:nodoc:
           dup.except!(*keys)
         end
 
-        # Replaces the hash without only the given keys.
+        # Replaces the hash without the given keys.
         def except!(*keys)
           keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
           keys.each { |key| delete(key) }

data/lib/active_support/core_ext/hash/reverse_merge.rb

@@ -1,21 +1,28 @@
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Hash #:nodoc:
-      # Allows for reverse merging where its the keys in the calling hash that wins over those in the <tt>other_hash</tt>.
-      # This is particularly useful for initializing an incoming option hash with default values:
+      # Allows for reverse merging two hashes where the keys in the calling hash take precedence over those
+      # in the <tt>other_hash</tt>. This is particularly useful for initializing an option hash with default values:
       #
       #   def setup(options = {})
       #     options.reverse_merge! :size => 25, :velocity => 10
       #   end
       #
-      # The default <tt>:size</tt> and <tt>:velocity</tt> is only set if the +options+ passed in doesn't already have those keys set.
+      # Using <tt>merge</tt>, the above example would look as follows:
+      #
+      #   def setup(options = {})
+      #     { :size => 25, :velocity => 10 }.merge(options)
+      #   end
+      #
+      # The default <tt>:size</tt> and <tt>:velocity</tt> are only set if the +options+ hash passed in doesn't already
+      # have the respective key.
       module ReverseMerge
-        # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+        # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
         def reverse_merge(other_hash)
           other_hash.merge(self)
         end
 
-        # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+        # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
         # Modifies the receiver in place.
         def reverse_merge!(other_hash)
           replace(reverse_merge(other_hash))

data/lib/active_support/core_ext/hash/slice.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Hash #:nodoc:
@@ -11,12 +9,17 @@ module ActiveSupport #:nodoc:
       #   end
       #
       #   search(options.slice(:mass, :velocity, :time))
+      #
+      # If you have an array of keys you want to limit to, you should splat them:
+      #
+      #   valid_keys = [:mass, :velocity, :time]
+      #   search(options.slice(*valid_keys))
       module Slice
         # Returns a new hash with only the given keys.
         def slice(*keys)
-          allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+          keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
           hash = self.class.new
-          allowed.each { |k| hash[k] = self[k] if has_key?(k) }
+          keys.each { |k| hash[k] = self[k] if has_key?(k) }
           hash
         end
 

data/lib/active_support/core_ext/integer.rb

@@ -1,7 +1,9 @@
 require 'active_support/core_ext/integer/even_odd'
 require 'active_support/core_ext/integer/inflections'
+require 'active_support/core_ext/integer/time'
 
 class Integer #:nodoc:
   include ActiveSupport::CoreExtensions::Integer::EvenOdd
   include ActiveSupport::CoreExtensions::Integer::Inflections
+  include ActiveSupport::CoreExtensions::Integer::Time
 end

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

@@ -0,0 +1,45 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Integer #:nodoc:
+      # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+      #
+      # These methods use Time#advance for precise date calculations when using from_now, ago, etc. 
+      # as well as adding or subtracting their results from a Time object. For example:
+      #
+      #   # equivalent to Time.now.advance(:months => 1)
+      #   1.month.from_now
+      #
+      #   # equivalent to Time.now.advance(:years => 2)
+      #   2.years.from_now
+      #
+      #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+      #   (4.months + 5.years).from_now
+      # 
+      # While these methods provide precise calculation when used as in the examples above, care
+      # should be taken to note that this is not true if the result of `months', `years', etc is
+      # converted before use:
+      #
+      #   # equivalent to 30.days.to_i.from_now
+      #   1.month.to_i.from_now
+      #
+      #   # equivalent to 365.25.days.to_f.from_now
+      #   1.year.to_f.from_now
+      #
+      # In such cases, Ruby's core
+      # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and
+      # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
+      # date and time arithmetic
+      module Time        
+        def months
+          ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
+        end
+        alias :month :months
+
+        def years
+          ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+        end
+        alias :year :years
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/kernel/debugger.rb

@@ -2,12 +2,12 @@ module Kernel
   unless respond_to?(:debugger)
     # Starts a debugging session if ruby-debug has been loaded (call script/server --debugger to do load it).
     def debugger
-      RAILS_DEFAULT_LOGGER.info "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
+      Rails.logger.info "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
     end
   end
-  
+
   def breakpoint
-    RAILS_DEFAULT_LOGGER.info "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
+    Rails.logger.info "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
     debugger
   end
-end
+end

data/lib/active_support/core_ext/logger.rb

@@ -12,5 +12,132 @@ class Logger
     end_eval
   end
   [:debug, :info, :error, :fatal].each {|level| define_around_helper(level) }
+end
 
-end
+
+require 'logger'
+
+# Extensions to the built in Ruby logger.
+#
+# If you want to use the default log formatter as defined in the Ruby core, then you
+# will need to set the formatter for the logger as in:
+#
+#   logger.formatter = Formatter.new
+#
+# You can then specify the datetime format, for example:
+#
+#   logger.datetime_format = "%Y-%m-%d"
+#
+# Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
+class Logger
+  # Set to false to disable the silencer
+  cattr_accessor :silencer
+  self.silencer = true
+
+  # Silences the logger for the duration of the block.
+  def silence(temporary_level = Logger::ERROR)
+    if silencer
+      begin
+        old_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
+    else
+      yield self
+    end
+  end
+
+  alias :old_datetime_format= :datetime_format=
+  # Logging date-time format (string passed to +strftime+). Ignored if the formatter
+  # does not respond to datetime_format=.
+  def datetime_format=(datetime_format)
+    formatter.datetime_format = datetime_format if formatter.respond_to?(:datetime_format=)
+  end
+
+  alias :old_datetime_format :datetime_format
+  # Get the logging datetime format. Returns nil if the formatter does not support
+  # datetime formatting.
+  def datetime_format
+    formatter.datetime_format if formatter.respond_to?(:datetime_format)
+  end
+
+  alias :old_formatter :formatter if method_defined?(:formatter)
+  # Get the current formatter. The default formatter is a SimpleFormatter which only
+  # displays the log message
+  def formatter
+    @formatter ||= SimpleFormatter.new
+  end
+
+  unless const_defined? :Formatter
+    class Formatter
+      Format = "%s, [%s#%d] %5s -- %s: %s\n"
+
+      attr_accessor :datetime_format
+
+      def initialize
+        @datetime_format = nil
+      end
+
+      def call(severity, time, progname, msg)
+        Format % [severity[0..0], format_datetime(time), $$, severity, progname,
+        msg2str(msg)]
+      end
+
+      private
+        def format_datetime(time)
+          if @datetime_format.nil?
+            time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % time.usec
+          else
+            time.strftime(@datetime_format)
+          end
+        end
+
+        def msg2str(msg)
+          case msg
+          when ::String
+            msg
+          when ::Exception
+            "#{ msg.message } (#{ msg.class })\n" <<
+            (msg.backtrace || []).join("\n")
+          else
+            msg.inspect
+          end
+        end
+    end
+  end
+
+  # Simple formatter which only displays the message.
+  class SimpleFormatter < Logger::Formatter
+    # This method is invoked when a log event occurs
+    def call(severity, timestamp, progname, msg)
+      "#{String === msg ? msg : msg.inspect}\n"
+    end
+  end
+
+  private
+    alias old_format_message format_message
+
+    # Ruby 1.8.3 transposed the msg and progname arguments to format_message.
+    # We can't test RUBY_VERSION because some distributions don't keep Ruby
+    # and its standard library in sync, leading to installations of Ruby 1.8.2
+    # with Logger from 1.8.3 and vice versa.
+    if method_defined?(:formatter=)
+      def format_message(severity, timestamp, progname, msg)
+        formatter.call(severity, timestamp, progname, msg)
+      end
+    else
+      def format_message(severity, timestamp, msg, progname)
+        formatter.call(severity, timestamp, progname, msg)
+      end
+
+      attr_writer :formatter
+      public :formatter=
+
+      alias old_format_datetime format_datetime
+      def format_datetime(datetime) datetime end
+
+      alias old_msg2str msg2str
+      def msg2str(msg) msg end
+    end
+end

data/lib/active_support/core_ext/module.rb

@@ -7,7 +7,17 @@ require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/module/loading'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/model_naming'
+require 'active_support/core_ext/module/synchronization'
+
+module ActiveSupport
+  module CoreExtensions
+    # Various extensions for the Ruby core Module class.
+    module Module
+      # Nothing here. Only defined for API documentation purposes.
+    end
+  end
+end
 
 class Module
-  include ActiveSupport::CoreExt::Module::ModelNaming
+  include ActiveSupport::CoreExtensions::Module
 end

data/lib/active_support/core_ext/module/aliasing.rb

@@ -1,70 +1,74 @@
-class Module
-  # Encapsulates the common pattern of:
-  #
-  #   alias_method :foo_without_feature, :foo
-  #   alias_method :foo, :foo_with_feature
-  #
-  # With this, you simply do:
-  #
-  #   alias_method_chain :foo, :feature
-  #
-  # And both aliases are set up for you.
-  #
-  # Query and bang methods (foo?, foo!) keep the same punctuation:
-  #
-  #   alias_method_chain :foo?, :feature
-  #
-  # is equivalent to
-  #
-  #   alias_method :foo_without_feature?, :foo?
-  #   alias_method :foo?, :foo_with_feature?
-  #
-  # so you can safely chain foo, foo?, and foo! with the same feature.
-  def alias_method_chain(target, feature)
-    # Strip out punctuation on predicates or bang methods since
-    # e.g. target?_without_feature is not a valid method name.
-    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-    yield(aliased_target, punctuation) if block_given?
-    
-    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
-    
-    alias_method without_method, target
-    alias_method target, with_method
-    
-    case
-      when public_method_defined?(without_method)
-        public target
-      when protected_method_defined?(without_method)
-        protected target
-      when private_method_defined?(without_method)
-        private target
-    end
-  end
+module ActiveSupport
+  module CoreExtensions
+    module Module
+      # Encapsulates the common pattern of:
+      #
+      #   alias_method :foo_without_feature, :foo
+      #   alias_method :foo, :foo_with_feature
+      #
+      # With this, you simply do:
+      #
+      #   alias_method_chain :foo, :feature
+      #
+      # And both aliases are set up for you.
+      #
+      # Query and bang methods (foo?, foo!) keep the same punctuation:
+      #
+      #   alias_method_chain :foo?, :feature
+      #
+      # is equivalent to
+      #
+      #   alias_method :foo_without_feature?, :foo?
+      #   alias_method :foo?, :foo_with_feature?
+      #
+      # so you can safely chain foo, foo?, and foo! with the same feature.
+      def alias_method_chain(target, feature)
+        # Strip out punctuation on predicates or bang methods since
+        # e.g. target?_without_feature is not a valid method name.
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        yield(aliased_target, punctuation) if block_given?
+
+        with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
 
-  # Allows you to make aliases for attributes, which includes 
-  # getter, setter, and query methods.
-  #
-  # Example:
-  #
-  #   class Content < ActiveRecord::Base
-  #     # has a title attribute
-  #   end
-  #
-  #   class Email < Content
-  #     alias_attribute :subject, :title
-  #   end
-  #
-  #   e = Email.find(1)
-  #   e.title    # => "Superstars"
-  #   e.subject  # => "Superstars"
-  #   e.subject? # => true
-  #   e.subject = "Megastars"
-  #   e.title    # => "Megastars"
-  def alias_attribute(new_name, old_name)
-    module_eval <<-STR, __FILE__, __LINE__+1
-      def #{new_name}; self.#{old_name}; end
-      def #{new_name}?; self.#{old_name}?; end
-      def #{new_name}=(v); self.#{old_name} = v; end
-    STR
+        alias_method without_method, target
+        alias_method target, with_method
+
+        case
+          when public_method_defined?(without_method)
+            public target
+          when protected_method_defined?(without_method)
+            protected target
+          when private_method_defined?(without_method)
+            private target
+        end
+      end
+
+      # Allows you to make aliases for attributes, which includes
+      # getter, setter, and query methods.
+      #
+      # Example:
+      #
+      #   class Content < ActiveRecord::Base
+      #     # has a title attribute
+      #   end
+      #
+      #   class Email < Content
+      #     alias_attribute :subject, :title
+      #   end
+      #
+      #   e = Email.find(1)
+      #   e.title    # => "Superstars"
+      #   e.subject  # => "Superstars"
+      #   e.subject? # => true
+      #   e.subject = "Megastars"
+      #   e.title    # => "Megastars"
+      def alias_attribute(new_name, old_name)
+        module_eval <<-STR, __FILE__, __LINE__+1
+          def #{new_name}; self.#{old_name}; end
+          def #{new_name}?; self.#{old_name}?; end
+          def #{new_name}=(v); self.#{old_name} = v; end
+        STR
+      end
+    end
   end
 end