activesupport 1.2.5 → 1.3.0

data/CHANGELOG

@@ -1,12 +1,171 @@
-*1.2.5* (December 13th, 2005)
+*1.3.0* (March 27th, 2005)
 
-* Become part of Rails 1.0
+* When possible, avoid incorrectly obtaining constants from parent modules. Fixes #4221. [Nicholas Seckar]
 
+* Add more tests for dependencies; refactor existing cases. [Nicholas Seckar]
 
-*1.2.4* (December 7th, 2005)
+* Move Module#parent and Module#as_load_path into core_ext. Add Module#parent. [Nicholas Seckar]
 
-* Rename Version constant to VERSION. #2802 [Marcel Molina Jr.]
+* Add CachingTools::HashCaching to simplify the creation of nested, autofilling hashes. [Nicholas Seckar]
+
+* Remove a hack intended to avoid unloading the same class twice, but which would not work anyways. [Nicholas Seckar]
+
+* Update Object.subclasses_of to locate nested classes. This affects Object.remove_subclasses_of in that nested classes will now be unloaded. [Nicholas Seckar]
+
+* Update Object.remove_subclasses_of to use Class.remove_class, reducing duplication. [Nicholas Seckar]
+
+* Added Fixnum#seconds for consistency, so you can say 5.minutes + 30.seconds instead of 5.minutes + 30 #4389 [François Beausoleil]
+
+* Added option to String#camelize to generate lower-cased camel case by passing in :lower, like "super_man".camelize(:lower) # => "superMan" [DHH]
+
+* Added Hash#diff to show the difference between two hashes [Chris McGrath]
+
+* Added Time#advance to do precise time time calculations for cases where a month being approximated to 30 days won't do #1860 [Rick Olson]
+
+* Enhance Inflector.underscore to convert '-' into '_' (as the inverse of Inflector.dasherize) [Jamis Buck]
+
+* Switched to_xml to use the xml schema format for datetimes.  This allows the encoding of time zones and should improve operability. [Koz]
+
+* Added a note to the documentation for the Date related Numeric extensions to indicate that they're
+approximations and shouldn't be used for critical calculations. [Koz]
+
+* Added Hash#to_xml and Array#to_xml that makes it much easier to produce XML from basic structures [DHH]. Examples:
+
+    { :name => "David", :street_name => "Paulina", :age => 26, :moved_on => Date.new(2005, 11, 15) }.to_xml
+    
+  ...returns:
+
+      <person>
+        <street-name>Paulina</street-name>
+        <name>David</name>
+        <age type="integer">26</age>
+        <moved-on type="date">2005-11-15</moved-on>
+      </person>
+
+* Moved Jim Weirich's wonderful Builder from Action Pack to Active Support (it's simply too useful to be stuck in AP) [DHH]
+
+* Fixed that Array#to_sentence will return "" on an empty array instead of ", and" #3842, #4031 [rubyonrails@beautifulpixel.com]
+
+* Add Enumerable#group_by for grouping collections based on the result of some
+  block. Useful, for example, for grouping records by date.
+
+  ex.
+
+     latest_transcripts.group_by(&:day).each do |day, transcripts| 
+       p "#{day} -> #{transcripts.map(&:class) * ', '}"
+     end
+     "2006-03-01 -> Transcript"
+     "2006-02-28 -> Transcript"
+     "2006-02-27 -> Transcript, Transcript"
+     "2006-02-26 -> Transcript, Transcript"
+
+  Add Array#in_groups_of, for iterating over an array in groups of a certain
+  size.
+
+  ex.
+
+     %w(1 2 3 4 5 6 7).in_groups_of(3) {|g| p g}
+     ["1", "2", "3"]
+     ["4", "5", "6"]
+     ["7", nil, nil]
+
+  [Marcel Molina Jr., Sam Stephenson]
+
+* Added Kernel#daemonize to turn the current process into a daemon that can be killed with a TERM signal [DHH]
+
+* Add 'around' methods to Logger,  to make it easy to log before and after messages for a given block as requested in #3809. [Michael Koziarski]  Example:
+
+  logger.around_info("Start rendering component (#{options.inspect}): ", 
+                     "\n\nEnd of component rendering") { yield }
+
+* Added Time#beginning_of_quarter #3607 [cohen.jeff@gmail.com]
+
+* Fix Object.subclasses_of to only return currently defined objects [Jonathan Viney <jonathan@bluewire.net.nz>]
+
+* Fix constantize to properly handle names beginning with '::'. [Nicholas Seckar]
+
+* Make String#last return the string instead of nil when it is shorter than the limit [Scott Barron].
+
+* Added delegation support to Module that allows multiple delegations at once (unlike Forwardable in the stdlib) [DHH]. Example:
 
+    class Account < ActiveRecord::Base
+      has_one :subscription
+      delegate :free?, :paying?, :to => :subscription
+      delegate :overdue?, :to => "subscription.last_payment"
+    end
+    
+    account.free?    # => account.subscription.free?
+    account.overdue? # => account.subscription.last_payment.overdue?
+
+* Fix Reloadable to handle the case where a class that has been 'removed' has not yet been garbage collected. [Nicholas Seckar]
+
+* Don't allow Reloadable to be included into Modules.
+
+* Remove LoadingModule. [Nicholas Seckar]
+
+* Add documentation for Reloadable::Subclasses. [Nicholas Seckar]
+
+* Add Reloadable::Subclasses which handles the common case where a base class should not be reloaded, but its subclasses should be. [Nicholas Seckar]
+
+* Further improvements to reloading code [Nicholas Seckar, Trevor Squires]
+  
+  - All classes/modules which include Reloadable can define reloadable? for fine grained control of reloading
+  - Class.remove_class uses Module#parent to access the parent module
+  - Class.remove_class expanded to handle multiple classes in a single call
+  - LoadingModule.clear! has been removed as it is no longer required
+  - Module#remove_classes_including has been removed in favor of Reloadable.reloadable_classes
+
+* Added reusable reloading support through the inclusion of the Relodable module that all subclasses of ActiveRecord::Base, ActiveRecord::Observer, ActiveController::Base, and ActionMailer::Base automatically gets. This means that these classes will be reloaded by the dispatcher when Dependencies.mechanism = :load. You can make your own models reloadable easily:
+
+    class Setting
+      include Reloadable
+    end
+  
+  Reloading a class is done by removing its constant which will cause it to be loaded again on the next reference. [DHH]
+
+* Added auto-loading support for classes in modules, so Conductor::Migration will look for conductor/migration.rb and Conductor::Database::Settings will look for conductor/database/settings.rb [Nicholas Seckar]
+
+* Add Object#instance_exec, like instance_eval but passes its arguments to the block.  (Active Support will not override the Ruby 1.9 implementation of this method.) [Sam Stephenson]
+
+* Add Proc#bind(object) for changing a proc or block's self by returning a Method bound to the given object. Based on why the lucky stiff's "cloaker" method. [Sam Stephenson]
+
+* Fix merge and dup for hashes with indifferent access #3404 [kenneth.miller@bitfield.net]
+
+* Fix the requires in option_merger_test to unbreak AS tests. [Sam Stephenson]
+
+* Make HashWithIndifferentAccess#update behave like Hash#update by returning the hash. #3419, #3425 [asnem@student.ethz.ch, JanPrill@blauton.de, Marcel Molina Jr.]
+
+* Add ActiveSupport::JSON and Object#to_json for converting Ruby objects to JSON strings. [Sam Stephenson]
+
+* Add Object#with_options for DRYing up multiple calls to methods having shared options. [Sam Stephenson]  Example:
+
+  ActionController::Routing::Routes.draw do |map|
+    # Account routes
+    map.with_options(:controller => 'account') do |account|
+      account.home   '',       :action => 'dashboard'
+      account.signup 'signup', :action => 'new'
+      account.logout 'logout', :action => 'logout'
+    end
+  end
+
+* Introduce Dependencies.warnings_on_first_load setting.  If true, enables warnings on first load of a require_dependency.  Otherwise, loads without warnings.  Disabled (set to false) by default.  [Jeremy Kemper]
+
+* Active Support is warnings-safe.  #1792 [Eric Hodel]
+
+* Introduce enable_warnings counterpart to silence_warnings.  Turn warnings on when loading a file for the first time if Dependencies.mechanism == :load.  Common mistakes such as redefined methods will print warnings to stderr.  [Jeremy Kemper]
+
+* Add Symbol#to_proc, which allows for, e.g. [:foo, :bar].map(&:to_s). [Marcel Molina Jr.]
+
+* Added the following methods [Marcel Molina Jr., Sam Stephenson]:
+  * Object#copy_instance_variables_from(object) to copy instance variables from one object to another 
+  * Object#extended_by to get an instance's included/extended modules
+  * Object#extend_with_included_modules_from(object) to extend an instance with the modules from another instance
+
+*1.2.5* (December 13th, 2005)
+
+* Become part of Rails 1.0
+
+* Rename Version constant to VERSION. #2802 [Marcel Molina Jr.]
 
 *1.2.3* (November 7th, 2005)
 

data/lib/active_support.rb

@@ -22,15 +22,20 @@
 #++
 
 $:.unshift(File.dirname(__FILE__))
+$:.unshift(File.dirname(__FILE__) + "/active_support/vendor")
+
+require 'builder'
 
-require 'active_support/class_attribute_accessors'
-require 'active_support/class_inheritable_attributes'
 require 'active_support/inflector'
 
 require 'active_support/core_ext'
 require 'active_support/clean_logger'
 require 'active_support/dependencies'
+require 'active_support/reloadable'
 
 require 'active_support/ordered_options'
+require 'active_support/option_merger'
+
+require 'active_support/values/time_zone'
 
-require 'active_support/values/time_zone'
+require 'active_support/json'

data/lib/active_support/breakpoint.rb

@@ -16,7 +16,7 @@
 # license please contact me.
 
 require 'irb'
-require File.dirname(__FILE__) + '/binding_of_caller'
+require File.dirname(__FILE__) + '/binding_of_caller' unless defined? Binding.of_caller
 require 'drb'
 require 'drb/acl'
 

data/lib/active_support/caching_tools.rb

@@ -0,0 +1,62 @@
+module ActiveSupport
+  module CachingTools #:nodoc:
+    
+    # Provide shortcuts to simply the creation of nested default hashes. This
+    # pattern is useful, common practice, and unsightly when done manually.
+    module HashCaching
+      # Dynamically create a nested hash structure used to cache calls to +method_name+
+      # The cache method is named +#{method_name}_cache+ unless :as => :alternate_name
+      # is given.
+      #
+      # The hash structure is created using nested Hash.new. For example:
+      # 
+      #   def slow_method(a, b) a ** b end
+      # 
+      # can be cached using hash_cache :slow_method, which will define the method
+      # slow_method_cache. We can then find the result of a ** b using:
+      # 
+      #   slow_method_cache[a][b]
+      # 
+      # The hash structure returned by slow_method_cache would look like this:
+      # 
+      #   Hash.new do |as, a|
+      #     as[a] = Hash.new do |bs, b|
+      #       bs[b] = slow_method(a, b)
+      #     end
+      #   end
+      # 
+      # The generated code is actually compressed onto a single line to maintain
+      # sensible backtrace signatures.
+      #
+      def hash_cache(method_name, options = {})
+        selector = options[:as] || "#{method_name}_cache"
+        method = self.instance_method(method_name)
+        
+        args = []
+        code = "def #{selector}(); @#{selector} ||= "
+        
+        (1..method.arity).each do |n|
+          args << "v#{n}"
+          code << "Hash.new {|h#{n}, v#{n}| h#{n}[v#{n}] = "
+        end
+        
+        # Add the method call with arguments, followed by closing braces and end.
+        code << "#{method_name}(#{args * ', '}) #{'}' * method.arity} end"
+        
+        # Extract the line number information from the caller. Exceptions arising
+        # in the generated code should point to the +hash_cache :...+ line.
+        if caller[0] && /^(.*):(\d+)$/ =~ caller[0]
+          file, line_number = $1, $2.to_i
+        else # We can't give good trackback info; fallback to this line:
+          file, line_number = __FILE__, __LINE__
+        end
+        
+        # We use eval rather than building proc's because it allows us to avoid
+        # linking the Hash's to this method's binding. Experience has shown that
+        # doing so can cause obtuse memory leaks.
+        class_eval code, file, line_number
+      end
+    end
+    
+  end
+end

data/lib/active_support/clean_logger.rb

@@ -1,5 +1,5 @@
 require 'logger'
-require File.dirname(__FILE__) + '/class_attribute_accessors'
+require File.dirname(__FILE__) + '/core_ext/class/attribute_accessors'
 
 class Logger #:nodoc:
   cattr_accessor :silencer
@@ -20,6 +20,8 @@ class Logger #:nodoc:
   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

data/lib/active_support/core_ext/array.rb

@@ -2,4 +2,20 @@ require File.dirname(__FILE__) + '/array/conversions'
 
 class Array #:nodoc:
   include ActiveSupport::CoreExtensions::Array::Conversions
+
+  # Iterate over an array in groups of a certain size, padding any remaining 
+  # slots with specified value (<tt>nil</tt> by default).
+  # 
+  # E.g.
+  # 
+  #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|g| p g}
+  #   ["1", "2", "3"]
+  #   ["4", "5", "6"]
+  #   ["7", nil, nil]
+  def in_groups_of(number, fill_with = nil, &block)
+    require 'enumerator'
+    collection = dup
+    collection << fill_with until collection.size.modulo(number).zero?
+    collection.each_slice(number, &block)
+  end
 end

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

@@ -1,16 +1,17 @@
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Array #:nodoc:
-      # Enables to conversion of Arrays to human readable lists. ['one', 'two', 'three'] => "one, two, and three"
       module Conversions
         # Converts the array to comma-seperated sentence where the last element is joined by the connector word. Options:
         # * <tt>:connector</tt>: The word used to join the last element in arrays with more than two elements (default: "and")
-        # * <tt>:skip_last_comma</tt>: Set to true to return "a, b and c" instead of "a, b, and c".
+        # * <tt>:skip_last_comma</tt>: Set to true to return "a, b, and c" instead of "a, b and c".
         def to_sentence(options = {})
           options.assert_valid_keys(:connector, :skip_last_comma)
           options.reverse_merge! :connector => 'and', :skip_last_comma => false
           
           case length
+          	when 0
+          		""
             when 1
               self[0]
             when 2
@@ -24,6 +25,21 @@ module ActiveSupport #:nodoc:
         def to_param
           join '/'
         end
+        
+        def to_xml(options = {})
+          raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+
+          options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
+          options[:children] ||= options[:root].singularize
+          options[:indent]   ||= 2
+          options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+          root     = options.delete(:root)
+          children = options.delete(:children)
+
+          options[:builder].instruct! unless options.delete(:skip_instruct)
+          options[:builder].tag!(root.to_s.dasherize) { each { |e| e.to_xml(options.merge({ :skip_instruct => true, :root => children })) } }
+        end
       end
     end
   end

data/lib/active_support/core_ext/blank.rb

@@ -1,4 +1,16 @@
-# The methods here are provided to speed up function blank? in class Object
+class Object #:nodoc:
+  # "", "   ", nil, [], and {} are blank
+  def blank?
+    if respond_to?(:empty?) && respond_to?(:strip)
+      empty? or strip.empty?
+    elsif respond_to?(:empty?)
+      empty?
+    else
+      !self
+    end
+  end
+end
+
 class NilClass #:nodoc:
   def blank?
     true
@@ -35,4 +47,4 @@ class Numeric #:nodoc:
   def blank?
     false
   end
-end
+end

data/lib/active_support/core_ext/class.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/class/attribute_accessors'
+require File.dirname(__FILE__) + '/class/inheritable_attributes'
+require File.dirname(__FILE__) + '/class/removal'

data/lib/active_support/core_ext/class/attribute_accessors.rb

@@ -0,0 +1,44 @@
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/active_support/{class_inheritable_attributes.rb → core_ext/class/inheritable_attributes.rb}

@@ -110,8 +110,6 @@ class Class # :nodoc:
       child.instance_variable_set('@inheritable_attributes', inheritable_attributes.dup)
     end
 
-    if respond_to?(:inherited)
-      alias_method :inherited_without_inheritable_attributes, :inherited
-    end
-    alias_method :inherited, :inherited_with_inheritable_attributes
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
 end

data/lib/active_support/core_ext/class/removal.rb

@@ -0,0 +1,24 @@
+class Class #:nodoc:
+  def remove_subclasses
+    Object.remove_subclasses_of(self)
+  end
+
+  def subclasses
+    Object.subclasses_of(self).map { |o| o.to_s }
+  end
+
+  def remove_class(*klasses)
+    klasses.flatten.each do |klass|
+      # Skip this class if there is nothing bound to this name
+      next unless defined?(klass.name)
+      
+      basename = klass.to_s.split("::").last
+      parent = klass.parent
+      
+      # Skip this class if it does not match the current one bound to this name
+      next unless parent.const_defined?(basename) && klass = parent.const_get(basename)
+      
+      parent.send :remove_const, basename unless parent == klass
+    end
+  end
+end