activesupport 3.0.0.beta4 → 3.0.pre

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

@@ -1,22 +1,18 @@
 class Array
   # Wraps the object in an Array unless it's an Array.  Converts the
   # object to an Array using #to_ary if it implements that.
-  #
-  # It differs with Array() in that it does not call +to_a+ on
-  # the argument:
-  #
-  #   Array(:foo => :bar)      # => [[:foo, :bar]]
-  #   Array.wrap(:foo => :bar) # => [{:foo => :bar}]
-  #
-  #   Array("foo\nbar")        # => ["foo\n", "bar"], in Ruby 1.8
-  #   Array.wrap("foo\nbar")   # => ["foo\nbar"]
   def self.wrap(object)
-    if object.nil?
+    case object
+    when nil
       []
-    elsif object.respond_to?(:to_ary)
-      object.to_ary
+    when self
+      object
     else
-      [object]
+      if object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        [object]
+      end
     end
   end
 end

data/lib/active_support/core_ext/benchmark.rb

@@ -1,6 +1,18 @@
 require 'benchmark'
 
 class << Benchmark
+  # Earlier Ruby had a slower implementation.
+  if RUBY_VERSION < '1.8.7'
+    remove_method :realtime
+
+    def realtime
+      r0 = Time.now
+      yield
+      r1 = Time.now
+      r1.to_f - r0.to_f
+    end
+  end
+
   def ms
     1000 * realtime { yield }
   end

data/lib/active_support/core_ext/boolean.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/boolean/conversions'

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

@@ -0,0 +1,11 @@
+class TrueClass
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  def to_param
+    self
+  end
+end

data/lib/active_support/core_ext/cgi/escape_skipping_slashes.rb

@@ -1,5 +1,3 @@
-require 'cgi'
-
 class CGI #:nodoc:
   if RUBY_VERSION >= '1.9'
     def self.escape_skipping_slashes(str)

data/lib/active_support/core_ext/class.rb

@@ -1,4 +1,4 @@
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/class/removal'
 require 'active_support/core_ext/class/delegating_attributes'
-require 'active_support/core_ext/class/subclasses'

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

@@ -10,48 +10,42 @@ require 'active_support/core_ext/array/extract_options'
 #  Person.hair_colors = [:brown, :black, :blonde, :red]
 class Class
   def cattr_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
+        unless defined? @@#{sym}  # unless defined? @@hair_colors
+          @@#{sym} = nil          #   @@hair_colors = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+                                  #
+        def #{sym}                # def hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
       EOS
-
-      unless options[:instance_reader] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
     end
   end
 
   def cattr_writer(*syms)
     options = syms.extract_options!
-    syms.each do |sym|
+    syms.flatten.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
+        unless defined? @@#{sym}                       # unless defined? @@hair_colors
+          @@#{sym} = nil                               #   @@hair_colors = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
       EOS
-
-      unless options[:instance_writer] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
-      end
       self.send("#{sym}=", yield) if block_given?
     end
   end

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

@@ -1,44 +1,50 @@
 require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/remove_method'
 
 class Class
-  def superclass_delegating_accessor(name, options = {})
-    # Create private _name and _name= methods that can still be used if the public
-    # methods are overridden. This allows
-    _superclass_delegating_accessor("_#{name}")
-
-    # Generate the public methods name, name=, and name?
-    # These methods dispatch to the private _name, and _name= methods, making them
-    # overridable
-    singleton_class.send(:define_method, name) { send("_#{name}") }
-    singleton_class.send(:define_method, "#{name}?") { !!send("_#{name}") }
-    singleton_class.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }
-
-    # If an instance_reader is needed, generate methods for name and name= on the
-    # class itself, so instances will be able to see them
-    define_method(name) { send("_#{name}") } if options[:instance_reader] != false
-    define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
-  end
-
-private
-
-  # Take the object being set and store it in a method. This gives us automatic
-  # inheritance behavior, without having to store the object in an instance
-  # variable and look up the superclass chain manually.
-  def _stash_object_in_method(object, method, instance_reader = true)
-    singleton_class.remove_possible_method(method)
-    singleton_class.send(:define_method, method) { object }
-    remove_possible_method(method)
-    define_method(method) { object } if instance_reader
+  def superclass_delegating_reader(*names)
+    class_name_to_stop_searching_on = superclass.name.blank? ? "Object" : superclass.name
+    names.each do |name|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{name}                                            # def self.only_reader
+          if defined?(@#{name})                                     #   if defined?(@only_reader)
+            @#{name}                                                #     @only_reader
+          elsif superclass < #{class_name_to_stop_searching_on} &&  #   elsif superclass < Object &&
+                superclass.respond_to?(:#{name})                    #         superclass.respond_to?(:only_reader)
+            superclass.#{name}                                      #     superclass.only_reader
+          end                                                       #   end
+        end                                                         # end
+        def #{name}                                                 # def only_reader
+          self.class.#{name}                                        #   self.class.only_reader
+        end                                                         # end
+        def self.#{name}?                                           # def self.only_reader?
+          !!#{name}                                                 #   !!only_reader
+        end                                                         # end
+        def #{name}?                                                # def only_reader?
+          !!#{name}                                                 #   !!only_reader
+        end                                                         # end
+      EOS
+    end
   end
 
-  def _superclass_delegating_accessor(name, options = {})
-    singleton_class.send(:define_method, "#{name}=") do |value|
-      _stash_object_in_method(value, name, options[:instance_reader] != false)
+  def superclass_delegating_writer(*names, &block)
+    names.each do |name|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{name}=(value)     # def self.property=(value)
+          @#{name} = value           #   @property = value
+        end                          # end
+      EOS
+      self.send("#{name}=", yield) if block_given?
     end
-    send("#{name}=", nil)
   end
 
+  # These class attributes behave something like the class
+  # inheritable accessors.  But instead of copying the hash over at
+  # the time the subclass is first defined, the accessors simply
+  # delegate to their superclass unless they have been given a 
+  # specific value.  This stops the strange situation where values 
+  # set after class definition don't get applied to subclasses.
+  def superclass_delegating_accessor(*names, &block)
+    superclass_delegating_reader(*names)
+    superclass_delegating_writer(*names, &block)
+  end
 end

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

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/array/extract_options'
 
 # Retain for backward compatibility.  Methods are now included in Class.
 module ClassInheritableAttributes # :nodoc:
@@ -9,24 +8,18 @@ end
 # their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
 # to, for example, an array without those additions being shared with either their parent, siblings, or
 # children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
-#
-# The copies of inheritable parent attributes are added to subclasses when they are created, via the
-# +inherited+ hook.
 class Class # :nodoc:
   def class_inheritable_reader(*syms)
-    options = syms.extract_options!
     syms.each do |sym|
       next if sym.is_a?(Hash)
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}                                # def self.after_add
-          read_inheritable_attribute(:#{sym})          #   read_inheritable_attribute(:after_add)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}                                     # def after_add
-          self.class.#{sym}                            #   self.class.after_add
-        end                                            # end
-        " unless options[:instance_reader] == false }  # # the reader above is generated unless options[:instance_reader] == false
+        def self.#{sym}                         # def self.after_add
+          read_inheritable_attribute(:#{sym})   #   read_inheritable_attribute(:after_add)
+        end                                     # end
+
+        def #{sym}                              # def after_add
+          self.class.#{sym}                     #   self.class.after_add
+        end                                     # end
       EOS
     end
   end
@@ -162,8 +155,8 @@ class Class
   #   (error out or do the same as other methods above) instead of silently
   #   moving on). In particular, this makes the return value of this function
   #   less useful.
-  def extlib_inheritable_reader(*ivars, &block)
-    options = ivars.extract_options!
+  def extlib_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
 
     ivars.each do |ivar|
       self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -171,17 +164,16 @@ class Class
           return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
           ivar = superclass.#{ivar}
           return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
-          @#{ivar} = ivar.duplicable? ? ivar.dup : ivar
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
         end
       RUBY
-      unless options[:instance_reader] == false
+      unless instance_reader == false
         self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{ivar}
             self.class.#{ivar}
           end
         RUBY
       end
-      instance_variable_set(:"@#{ivar}", yield) if block_given?
     end
   end
 
@@ -198,15 +190,14 @@ class Class
   # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
   #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
   def extlib_inheritable_writer(*ivars)
-    options = ivars.extract_options!
-
+    instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
     ivars.each do |ivar|
       self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def self.#{ivar}=(obj)
           @#{ivar} = obj
         end
       RUBY
-      unless options[:instance_writer] == false
+      unless instance_writer == false
         self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{ivar}=(obj) self.class.#{ivar} = obj end
         RUBY

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

@@ -0,0 +1,53 @@
+require 'active_support/core_ext/object/extending'
+require 'active_support/core_ext/module/introspection'
+
+class Class #:nodoc:
+  
+  # Unassociates the class with its subclasses and removes the subclasses
+  # themselves.
+  #
+  #   Integer.remove_subclasses # => [Bignum, Fixnum]
+  #   Fixnum                    # => NameError: uninitialized constant Fixnum
+  def remove_subclasses
+    Object.remove_subclasses_of(self)
+  end
+
+  # Returns an array with the names of the subclasses of +self+ as strings.
+  #
+  #   Integer.subclasses # => ["Bignum", "Fixnum"]
+  def subclasses
+    Object.subclasses_of(self).map { |o| o.to_s }
+  end
+
+  # Removes the classes in +klasses+ from their parent module.
+  #
+  # Ordinary classes belong to some module via a constant. This method computes
+  # that constant name from the class name and removes it from the module it
+  # belongs to.
+  #
+  #   Object.remove_class(Integer) # => [Integer]
+  #   Integer                      # => NameError: uninitialized constant Integer
+  #
+  # Take into account that in general the class object could be still stored
+  # somewhere else.
+  #
+  #   i = Integer                  # => Integer
+  #   Object.remove_class(Integer) # => [Integer]
+  #   Integer                      # => NameError: uninitialized constant Integer
+  #   i.subclasses                 # => ["Bignum", "Fixnum"]
+  #   Fixnum.superclass            # => Integer
+  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.instance_eval { remove_const basename } unless parent == klass
+    end
+  end
+end

data/lib/active_support/core_ext/date.rb

@@ -0,0 +1,7 @@
+require 'date'
+
+require 'active_support/core_ext/date/acts_like'
+require 'active_support/core_ext/date/freeze'
+
+require 'active_support/core_ext/date/calculations'
+require 'active_support/core_ext/date/conversions'

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

@@ -1,36 +1,15 @@
-require 'date'
 require 'active_support/duration'
-require 'active_support/core_ext/time/zones'
-require 'active_support/core_ext/object/acts_like'
 
 class Date
-  if RUBY_VERSION < '1.9'
-    undef :>>
-    
-    # Backported from 1.9. The one in 1.8 leads to incorrect next_month and
-    # friends for dates where the calendar reform is involved. It additionally
-    # prevents an infinite loop fixed in r27013.
-    def >>(n)
-      y, m = (year * 12 + (mon - 1) + n).divmod(12)
-      m,   = (m + 1)                    .divmod(1)
-      d = mday
-      until jd2 = self.class.valid_civil?(y, m, d, start)
-        d -= 1
-        raise ArgumentError, 'invalid date' unless d > 0
-      end
-      self + (jd2 - jd)
-    end
-  end
-
   class << self
     # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
     def yesterday
-      ::Date.current.yesterday
+      ::Date.today.yesterday
     end
 
     # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
     def tomorrow
-      ::Date.current.tomorrow
+      ::Date.today.tomorrow
     end
 
     # Returns Time.zone.today when config.time_zone is set, otherwise just returns Date.today.
@@ -146,20 +125,20 @@ class Date
     advance(:years => years)
   end
 
-  # Shorthand for years_ago(1)
-  def prev_year
+  # Short-hand for years_ago(1)
+  def last_year
     years_ago(1)
-  end unless method_defined?(:prev_year)
+  end
 
   # Short-hand for years_since(1)
   def next_year
     years_since(1)
   end unless method_defined?(:next_year)
-  
+
   # Short-hand for months_ago(1)
-  def prev_month
+  def last_month
     months_ago(1)
-  end unless method_defined?(:prev_month)
+  end
 
   # Short-hand for months_since(1)
   def next_month
@@ -181,7 +160,6 @@ class Date
     result = self + days_to_sunday.days
     self.acts_like?(:time) ? result.end_of_day : result
   end
-  alias :sunday :end_of_week
   alias :at_end_of_week :end_of_week
 
   # Returns a new Date/DateTime representing the start of the given day in next week (default is Monday).