activesupport 2.3.5 → 3.0.0.beta3

data/CHANGELOG

@@ -1,23 +1,80 @@
-*2.3.5 (November 25, 2009)*
+*Rails 3.0.0 [beta 3] (April 13th, 2010)*
 
-* Minor Bug Fixes and deprecation warnings
+* Improve transliteration quality.  #4374 [Norman Clarke]
 
-* Fixes for the Nokogiri backend for XmlMini
+* Speed up and add Ruby 1.9 support for ActiveSupport::Multibyte::Chars#tidy_bytes.  #4350 [Norman Clarke]
 
-* Ruby 1.9 Compatibility
 
-*2.3.4 (September 4, 2009)*
+*Rails 3.0.0 [beta 2] (April 1st, 2010)*
 
-* Introduce ActiveSupport::Multibyte.clean to clean invalid multibyte strings.
+* Reduced load time by deferring configuration of classes using
+  ActiveSupport::on_load(:component_name) [YK]
 
-* Bug fixes
+* Rename #metaclass to #singleton_class now that ruby-core has decided [JK]
 
-*2.3.3 (July 12, 2009)*
+* New assertions assert_blank and assert_present.  #4299 [Juanjo Bazan] 
 
-* JSON: +Object#to_json+ calls +as_json+ to coerce itself into something natively encodable like +Hash+, +Integer+, or +String+. Override +as_json+ instead of +to_json+ so you're JSON-library-agnostic.  [Jeremy Kemper]
+* Use Object#singleton_class instead of #metaclass. Prefer Ruby's choice.  [Jeremy Kemper]
+
+* JSON backend for YAJL. Preferred if available.  #2666 [Brian Lopez]
+
+
+*Rails 3.0.0 [beta 1] (February 4, 2010)*
+
+* Introduce class_attribute to declare inheritable class attributes. Writing an attribute on a subclass behaves just like overriding the superclass reader method.  Unifies and replaces most usage of cattr_accessor, class_inheritable_attribute, superclass_delegating_attribute, and extlib_inheritable_attribute.  [Jeremy Kemper, Yehuda Katz]
+
+* Time#- with a DateTime argument behaves the same as with a Time argument, i.e. returns the difference between self and arg as a Float #3476 [Geoff Buesing]
+
+* YAML serialization for OrderedHash.  #3608 [Gregor Schmidt]
+
+* Update bundled TZInfo to v0.3.16 [Geoff Buesing]
+
+* Georgetown TimeZone is now mapped to "America/Guyana" instead of "America/Argentina/San_Juan" #1821 [Geoff Buesing, Reuben Sivan]
+
+* Changed the default ActiveSupport.use_standard_json_time_format from false to true and
+ActiveSupport.escape_html_entities_in_json from true to false to match previously announced Rails 3 defaults [DHH]
+
+* Added Object#presence that returns the object if it's #present? otherwise returns nil [DHH/Colin Kelley]
+
+* Add Enumerable#exclude? to bring parity to Enumerable#include? and avoid if !x.include?/else calls [DHH]
+
+* Update Edinburgh TimeZone to use "Europe/London" instead of "Europe/Dublin" #3310 [Phil Ross]
+
+* Update bundled TZInfo to v0.3.15 [Geoff Buesing]
+
+* JSON: +Object#to_json+ calls +as_json+ to coerce itself into something natively encodable like +Hash+, +Integer+, or +String+. Override +as_json+ instead of +to_json+ so you're JSON library agnostic.  [Jeremy Kemper]
+
+* String #to_time and #to_datetime: handle fractional seconds #864 [Jason Frey]
+
+* Update bundled TZInfo to v0.3.13 [Geoff Buesing]
 
 * Allow MemCacheStore to be initialized with a MemCache-like object instead of addresses and options [Bryan Helmkamp]
 
+* Change spelling of Kyev timezone to Kyiv #2613 [Alexander Dymo]
+
+* Add ActiveSupport.parse_json_times to disable time parsing in JSON backends that don't support it or don't need it. [rick]
+
+* Add pluggable JSON backends with support for the JSON gem. [rick]
+    Example: ActiveSupport::JSON.backend = "JSONGem"
+
+ All internal Rails JSON encoding is now handled by ActiveSupport::JSON.encode().  Use of #to_json is not recommended, as it may clash with other libraries that overwrite it.  However, you can recover Rails specific functionality
+ if you really want to use #to_json.
+
+    gem 'json'
+    ActiveSupport::JSON.backend = "JSONGem"
+
+    class ActiveRecord::Base
+      alias to_json rails_to_json
+    end
+
+* require 'active_support' no longer orders the whole menu of core extensions. Ask for just what you need: e.g. require 'active_support/core/time' to use timezones, durations, and stdlib date/time extensions. [Jeremy Kemper]
+
+* Removed rarely-used DRb cache store.  [Jeremy Kemper]
+
+* TimeWithZone.name returns 'Time', to further thwart type checking [Geoff Buesing]
+
+* Time.local instances: Adding 24.hours across the DST boundary adds 24 hours instead of one day #2066 [Michael Curtis]
+
 
 *2.3.2 [Final] (March 15, 2009)*
 

data/lib/active_support/all.rb

@@ -1,8 +1,3 @@
-# For forward compatibility with Rails 3.
-#
-# require 'active_support' loads a very bare minumum in Rails 3.
-# require 'active_support/all' loads the whole suite like Rails 2 did.
-#
-# To prepare for Rails 3, switch to require 'active_support/all' now.
-
 require 'active_support'
+require 'active_support/time'
+require 'active_support/core_ext'

data/lib/active_support/backtrace_cleaner.rb

@@ -4,12 +4,14 @@ module ActiveSupport
   # context, so only the relevant lines are included.
   #
   # If you need to reconfigure an existing BacktraceCleaner, like the one in Rails, to show as much as possible, you can always
-  # call BacktraceCleaner#remove_silencers!
+  # call BacktraceCleaner#remove_silencers! Also, if you need to reconfigure an existing BacktraceCleaner so that it does not
+  # filter or modify the paths of any lines of the backtrace, you can call BacktraceCleaner#remove_filters! These two methods
+  # will give you a completely untouched backtrace.
   #
   # Example:
   #
   #   bc = BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root, '') } 
+  #   bc.add_filter   { |line| line.gsub(Rails.root, '') }
   #   bc.add_silencer { |line| line =~ /mongrel|rubygems/ }
   #   bc.clean(exception.backtrace) # will strip the Rails.root prefix and skip any lines from mongrel or rubygems
   #
@@ -18,10 +20,19 @@ module ActiveSupport
     def initialize
       @filters, @silencers = [], []
     end
-    
+
     # Returns the backtrace after all filters and silencers has been run against it. Filters run first, then silencers.
-    def clean(backtrace)
-      silence(filter(backtrace))
+    def clean(backtrace, kind = :silent)
+      filtered = filter(backtrace)
+
+      case kind
+      when :silent
+        silence(filtered)
+      when :noise
+        noise(filtered)
+      else
+        filtered
+      end
     end
 
     # Adds a filter from the block provided. Each line in the backtrace will be mapped against this filter.
@@ -51,21 +62,32 @@ module ActiveSupport
       @silencers = []
     end
 
-    
+    def remove_filters!
+      @filters = []
+    end
+
     private
       def filter(backtrace)
         @filters.each do |f|
           backtrace = backtrace.map { |line| f.call(line) }
         end
-        
+
         backtrace
       end
-      
+
       def silence(backtrace)
         @silencers.each do |s|
           backtrace = backtrace.reject { |line| s.call(line) }
         end
-        
+
+        backtrace
+      end
+
+      def noise(backtrace)
+        @silencers.each do |s|
+          backtrace = backtrace.select { |line| s.call(line) }
+        end
+
         backtrace
       end
   end

data/lib/active_support/base64.rb

@@ -30,4 +30,13 @@ module ActiveSupport
       end
     end
   end
+
+  # Encodes the value as base64 without the newline breaks. This makes the base64 encoding readily usable as URL parameters
+  # or memcache keys without further processing.
+  #
+  #  ActiveSupport::Base64.encode64s("Original unencoded string")
+  #  # => "T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw=="
+  def Base64.encode64s(value)
+    encode64(value).gsub(/\n/, '')
+  end
 end

data/lib/active_support/basic_object.rb

@@ -1,13 +1,7 @@
-# A base class with no predefined methods that tries to behave like Builder's
-# BlankSlate in Ruby 1.9. In Ruby pre-1.9, this is actually the
-# Builder::BlankSlate class.
-#
-# Ruby 1.9 introduces BasicObject which differs slightly from Builder's
-# BlankSlate that has been used so far. ActiveSupport::BasicObject provides a
-# barebones base class that emulates Builder::BlankSlate while still relying on
-# Ruby 1.9's BasicObject in Ruby 1.9.
 module ActiveSupport
   if defined? ::BasicObject
+    # A class with no predefined methods that behaves similarly to Builder's
+    # BlankSlate. Used for proxy classes.
     class BasicObject < ::BasicObject
       undef_method :==
       undef_method :equal?
@@ -18,7 +12,10 @@ module ActiveSupport
       end
     end
   else
-    require 'blankslate'
-    BasicObject = BlankSlate
+    class BasicObject #:nodoc:
+      instance_methods.each do |m|
+        undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$)/
+      end
+    end
   end
 end

data/lib/active_support/benchmarkable.rb

@@ -0,0 +1,60 @@
+require 'active_support/core_ext/benchmark'
+require 'active_support/core_ext/hash/keys'
+
+module ActiveSupport
+  module Benchmarkable
+    # Allows you to measure the execution time of a block 
+    # in a template and records the result to the log. Wrap this block around
+    # expensive operations or possible bottlenecks to get a time reading
+    # for the operation.  For example, let's say you thought your file 
+    # processing method was taking too long; you could wrap it in a benchmark block.
+    #
+    #  <% benchmark "Process data files" do %>
+    #    <%= expensive_files_operation %>
+    #  <% end %>
+    #
+    # That would add something like "Process data files (345.2ms)" to the log,
+    # which you can then use to compare timings when optimizing your code.
+    #
+    # You may give an optional logger level as the :level option.
+    # (:debug, :info, :warn, :error); the default value is :info.
+    #
+    #  <% benchmark "Low-level files", :level => :debug do %>
+    #    <%= lowlevel_files_operation %>
+    #  <% end %>
+    #
+    # Finally, you can pass true as the third argument to silence all log activity 
+    # inside the block. This is great for boiling down a noisy block to just a single statement:
+    #
+    #  <% benchmark "Process data files", :level => :info, :silence => true do %>
+    #    <%= expensive_and_chatty_files_operation %>
+    #  <% end %>
+    def benchmark(message = "Benchmarking", options = {})
+      if logger
+        if options.is_a?(Symbol)
+          ActiveSupport::Deprecation.warn("use benchmark('#{message}', :level => :#{options}) instead", caller)
+          options = { :level => options, :silence => false }
+        else
+          options.assert_valid_keys(:level, :silence)
+          options[:level] ||= :info
+        end
+
+        result = nil
+        ms = Benchmark.ms { result = options[:silence] ? logger.silence { yield } : yield }
+        logger.send(options[:level], '%s (%.1fms)' % [ message, ms ])
+        result
+      else
+        yield
+      end
+    end
+
+    # Silence the logger during the execution of the block.
+    #
+    def silence
+      old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger
+      yield
+    ensure
+      logger.level = old_logger_level if logger
+    end
+  end
+end

data/lib/active_support/buffered_logger.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/class/attribute_accessors'
+
 module ActiveSupport
   # Inspired by the buffered logger idea by Ezra
   class BufferedLogger
@@ -51,7 +53,6 @@ module ActiveSupport
         FileUtils.mkdir_p(File.dirname(log))
         @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
         @log.sync = true
-        @log.write("# Logfile created on %s" % [Time.now.to_s])
       end
     end
 
@@ -66,15 +67,19 @@ module ActiveSupport
       message
     end
 
+    # Dynamically add methods such as:
+    # def info
+    # def warn
+    # def debug
     for severity in Severity.constants
-      class_eval <<-EOT, __FILE__, __LINE__
-        def #{severity.downcase}(message = nil, progname = nil, &block)  # def debug(message = nil, progname = nil, &block)
-          add(#{severity}, message, progname, &block)                    #   add(DEBUG, message, progname, &block)
-        end                                                              # end
-                                                                         #
-        def #{severity.downcase}?                                        # def debug?
-          #{severity} >= @level                                          #   DEBUG >= @level
-        end                                                              # end
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{severity.downcase}(message = nil, progname = nil, &block) # def debug(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)                   #   add(DEBUG, message, progname, &block)
+        end                                                             # end
+
+        def #{severity.downcase}?                                       # def debug?
+          #{severity} >= @level                                         #   DEBUG >= @level
+        end                                                             # end
       EOT
     end
 

data/lib/active_support/cache/compressed_mem_cache_store.rb

@@ -1,3 +1,5 @@
+require 'active_support/gzip'
+
 module ActiveSupport
   module Cache
     class CompressedMemCacheStore < MemCacheStore

data/lib/active_support/cache/file_store.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/file/atomic'
+
 module ActiveSupport
   module Cache
     # A cache store implementation which stores everything on the filesystem.
@@ -8,43 +10,59 @@ module ActiveSupport
         @cache_path = cache_path
       end
 
+      # Reads a value from the cache.
+      #
+      # Possible options:
+      # - +:expires_in+ - the number of seconds that this value may stay in
+      #   the cache.
       def read(name, options = nil)
-        super
-        File.open(real_file_path(name), 'rb') { |f| Marshal.load(f) } rescue nil
+        super do
+          file_name = real_file_path(name)
+          expires = expires_in(options)
+
+          if File.exist?(file_name) && (expires <= 0 || Time.now - File.mtime(file_name) < expires)
+            File.open(file_name, 'rb') { |f| Marshal.load(f) }
+          end
+        end
       end
 
+      # Writes a value to the cache.
       def write(name, value, options = nil)
-        super
-        ensure_cache_path(File.dirname(real_file_path(name)))
-        File.atomic_write(real_file_path(name), cache_path) { |f| Marshal.dump(value, f) }
-        value
+        super do
+          ensure_cache_path(File.dirname(real_file_path(name)))
+          File.atomic_write(real_file_path(name), cache_path) { |f| Marshal.dump(value, f) }
+          value
+        end
       rescue => e
         logger.error "Couldn't create cache directory: #{name} (#{e.message})" if logger
       end
 
       def delete(name, options = nil)
-        super
-        File.delete(real_file_path(name))
+        super do
+          File.delete(real_file_path(name))
+        end
       rescue SystemCallError => e
         # If there's no cache, then there's nothing to complain about
       end
 
       def delete_matched(matcher, options = nil)
-        super
-        search_dir(@cache_path) do |f|
-          if f =~ matcher
-            begin
-              File.delete(f)
-            rescue SystemCallError => e
-              # If there's no cache, then there's nothing to complain about
+        super do
+          search_dir(@cache_path) do |f|
+            if f =~ matcher
+              begin
+                File.delete(f)
+              rescue SystemCallError => e
+                # If there's no cache, then there's nothing to complain about
+              end
             end
           end
         end
       end
 
       def exist?(name, options = nil)
-        super
-        File.exist?(real_file_path(name))
+        super do
+          File.exist?(real_file_path(name))
+        end
       end
 
       private

data/lib/active_support/cache/mem_cache_store.rb

@@ -1,4 +1,5 @@
 require 'memcache'
+require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
   module Cache
@@ -12,7 +13,7 @@ module ActiveSupport
     #   and MemCacheStore will load balance between all available servers. If a
     #   server goes down, then MemCacheStore will ignore it until it goes back
     #   online.
-    # - Time-based expiry support. See #write and the +:expires_in+ option.
+    # - Time-based expiry support. See #write and the <tt>:expires_in</tt> option.
     # - Per-request in memory cache for all communication with the MemCache server(s).
     class MemCacheStore < Store
       module Response # :nodoc:
@@ -59,39 +60,42 @@ module ActiveSupport
       end
 
       def read(key, options = nil) # :nodoc:
-        super
-        @data.get(key, raw?(options))
+        super do
+          @data.get(key, raw?(options))
+        end
       rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
+        logger.error("MemCacheError (#{e}): #{e.message}") if logger
         nil
       end
 
       # Writes a value to the cache.
       #
       # Possible options:
-      # - +:unless_exist+ - set to true if you don't want to update the cache
+      # - <tt>:unless_exist</tt> - set to true if you don't want to update the cache
       #   if the key is already set.
-      # - +:expires_in+ - the number of seconds that this value may stay in
+      # - <tt>:expires_in</tt> - the number of seconds that this value may stay in
       #   the cache. See ActiveSupport::Cache::Store#write for an example.
       def write(key, value, options = nil)
-        super
-        method = options && options[:unless_exist] ? :add : :set
-        # memcache-client will break the connection if you send it an integer
-        # in raw mode, so we convert it to a string to be sure it continues working.
-        value = value.to_s if raw?(options)
-        response = @data.send(method, key, value, expires_in(options), raw?(options))
-        response == Response::STORED
+        super do
+          method = options && options[:unless_exist] ? :add : :set
+          # memcache-client will break the connection if you send it an integer
+          # in raw mode, so we convert it to a string to be sure it continues working.
+          value = value.to_s if raw?(options)
+          response = @data.send(method, key, value, expires_in(options), raw?(options))
+          response == Response::STORED
+        end
       rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
+        logger.error("MemCacheError (#{e}): #{e.message}") if logger
         false
       end
 
       def delete(key, options = nil) # :nodoc:
-        super
-        response = @data.delete(key, expires_in(options))
-        response == Response::DELETED
+        super do
+          response = @data.delete(key)
+          response == Response::DELETED
+        end
       rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
+        logger.error("MemCacheError (#{e}): #{e.message}") if logger
         false
       end
 
@@ -99,21 +103,26 @@ module ActiveSupport
         # Doesn't call super, cause exist? in memcache is in fact a read
         # But who cares? Reading is very fast anyway
         # Local cache is checked first, if it doesn't know then memcache itself is read from
-        !read(key, options).nil?
+        super do
+          !read(key, options).nil?
+        end
       end
 
       def increment(key, amount = 1) # :nodoc:
-        log("incrementing", key, amount)
+        response = instrument(:increment, key, :amount => amount) do
+          @data.incr(key, amount)
+        end
 
-        response = @data.incr(key, amount)
         response == Response::NOT_FOUND ? nil : response
       rescue MemCache::MemCacheError
         nil
       end
 
       def decrement(key, amount = 1) # :nodoc:
-        log("decrement", key, amount)
-        response = @data.decr(key, amount)
+        response = instrument(:decrement, key, :amount => amount) do
+          @data.decr(key, amount)
+        end
+
         response == Response::NOT_FOUND ? nil : response
       rescue MemCache::MemCacheError
         nil

data/lib/active_support/cache/memory_store.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/duplicable'
+
 module ActiveSupport
   module Cache
     # A cache store implementation which stores everything into memory in the
@@ -20,28 +22,33 @@ module ActiveSupport
       end
 
       def read(name, options = nil)
-        super
-        @data[name]
+        super do
+          @data[name]
+        end
       end
 
       def write(name, value, options = nil)
-        super
-        @data[name] = value.freeze
+        super do
+          @data[name] = (value.duplicable? ? value.dup : value).freeze
+        end
       end
 
       def delete(name, options = nil)
-        super
-        @data.delete(name)
+        super do
+          @data.delete(name)
+        end
       end
 
       def delete_matched(matcher, options = nil)
-        super
-        @data.delete_if { |k,v| k =~ matcher }
+        super do
+          @data.delete_if { |k,v| k =~ matcher }
+        end
       end
 
       def exist?(name,options = nil)
-        super
-        @data.has_key?(name)
+        super do
+          @data.has_key?(name)
+        end
       end
 
       def clear

data/lib/active_support/cache/strategy/local_cache.rb

@@ -1,3 +1,6 @@
+require 'active_support/core_ext/object/duplicable'
+require 'active_support/core_ext/string/inflections'
+
 module ActiveSupport
   module Cache
     module Strategy
@@ -15,7 +18,7 @@ module ActiveSupport
         def middleware
           @middleware ||= begin
             klass = Class.new
-            klass.class_eval(<<-EOS, __FILE__, __LINE__)
+            klass.class_eval(<<-EOS, __FILE__, __LINE__ + 1)
               def initialize(app)
                 @app = app
               end
@@ -27,6 +30,11 @@ module ActiveSupport
                 Thread.current[:#{thread_local_key}] = nil
               end
             EOS
+
+            def klass.to_s
+              "ActiveSupport::Cache::Strategy::LocalCache"
+            end
+
             klass
           end
         end