activesupport 2.3.5 → 3.0.0.beta3

data/lib/active_support/core_ext/module.rb

@@ -1,23 +1,12 @@
-require 'active_support/core_ext/module/inclusion'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/introspection'
+require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/module/reachable'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/attr_internal'
 require 'active_support/core_ext/module/attr_accessor_with_default'
 require 'active_support/core_ext/module/delegation'
-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::CoreExtensions::Module
-end
+require 'active_support/core_ext/module/deprecation'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/module/method_names'

data/lib/active_support/core_ext/name_error.rb

@@ -1,12 +1,11 @@
-# Add a +missing_name+ method to NameError instances.
-class NameError #:nodoc:  
-  # Add a method to obtain the missing name from a NameError.
+class NameError
+  # Extract the name of the missing constant from the exception message.
   def missing_name
     if /undefined local variable or method/ !~ message
       $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
     end
   end
-  
+
   # Was this exception raised because the given name was missing?
   def missing_name?(name)
     if name.is_a? Symbol

data/lib/active_support/core_ext/numeric/bytes.rb

@@ -1,50 +1,44 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Numeric #:nodoc:
-      # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
-      module Bytes
-        KILOBYTE = 1024
-        MEGABYTE = KILOBYTE * 1024
-        GIGABYTE = MEGABYTE * 1024
-        TERABYTE = GIGABYTE * 1024
-        PETABYTE = TERABYTE * 1024
-        EXABYTE  = PETABYTE * 1024
+class Numeric
+  KILOBYTE = 1024
+  MEGABYTE = KILOBYTE * 1024
+  GIGABYTE = MEGABYTE * 1024
+  TERABYTE = GIGABYTE * 1024
+  PETABYTE = TERABYTE * 1024
+  EXABYTE  = PETABYTE * 1024
 
-        def bytes
-          self
-        end
-        alias :byte :bytes
+  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+  def bytes
+    self
+  end
+  alias :byte :bytes
 
-        def kilobytes
-          self * KILOBYTE
-        end
-        alias :kilobyte :kilobytes
+  def kilobytes
+    self * KILOBYTE
+  end
+  alias :kilobyte :kilobytes
 
-        def megabytes
-          self * MEGABYTE
-        end
-        alias :megabyte :megabytes
+  def megabytes
+    self * MEGABYTE
+  end
+  alias :megabyte :megabytes
 
-        def gigabytes
-          self * GIGABYTE
-        end
-        alias :gigabyte :gigabytes
+  def gigabytes
+    self * GIGABYTE
+  end
+  alias :gigabyte :gigabytes
 
-        def terabytes
-          self * TERABYTE
-        end
-        alias :terabyte :terabytes
+  def terabytes
+    self * TERABYTE
+  end
+  alias :terabyte :terabytes
 
-        def petabytes
-          self * PETABYTE
-        end
-        alias :petabyte :petabytes
+  def petabytes
+    self * PETABYTE
+  end
+  alias :petabyte :petabytes
 
-        def exabytes
-          self * EXABYTE
-        end
-        alias :exabyte :exabytes
-      end
-    end
+  def exabytes
+    self * EXABYTE
   end
+  alias :exabyte :exabytes
 end

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

@@ -1,81 +1,77 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Numeric #: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 seconds
-          ActiveSupport::Duration.new(self, [[:seconds, self]])
-        end
-        alias :second :seconds
+require 'active_support/duration'
 
-        def minutes
-          ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
-        end
-        alias :minute :minutes  
-        
-        def hours
-          ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
-        end
-        alias :hour :hours
-        
-        def days
-          ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
-        end
-        alias :day :days
+class Numeric
+  # 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
+  def seconds
+    ActiveSupport::Duration.new(self, [[:seconds, self]])
+  end
+  alias :second :seconds
 
-        def weeks
-          ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
-        end
-        alias :week :weeks
-        
-        def fortnights
-          ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
-        end
-        alias :fortnight :fortnights
-        
-        # Reads best without arguments:  10.minutes.ago
-        def ago(time = ::Time.now)
-          time - self
-        end
+  def minutes
+    ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
+  end
+  alias :minute :minutes  
+  
+  def hours
+    ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
+  end
+  alias :hour :hours
+  
+  def days
+    ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
+  end
+  alias :day :days
 
-        # Reads best with argument:  10.minutes.until(time)
-        alias :until :ago
+  def weeks
+    ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
+  end
+  alias :week :weeks
+  
+  def fortnights
+    ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
+  end
+  alias :fortnight :fortnights
+  
+  # Reads best without arguments:  10.minutes.ago
+  def ago(time = ::Time.now)
+    time - self
+  end
 
-        # Reads best with argument:  10.minutes.since(time)
-        def since(time = ::Time.now)
-          time + self
-        end
+  # Reads best with argument:  10.minutes.until(time)
+  alias :until :ago
 
-        # Reads best without arguments:  10.minutes.from_now
-        alias :from_now :since
-      end
-    end
+  # Reads best with argument:  10.minutes.since(time)
+  def since(time = ::Time.now)
+    time + self
   end
+
+  # Reads best without arguments:  10.minutes.from_now
+  alias :from_now :since
 end

data/lib/active_support/core_ext/numeric.rb

@@ -1,9 +1,2 @@
-require 'active_support/core_ext/numeric/time'
 require 'active_support/core_ext/numeric/bytes'
-require 'active_support/core_ext/numeric/conversions'
-
-class Numeric #:nodoc:
-  include ActiveSupport::CoreExtensions::Numeric::Time 
-  include ActiveSupport::CoreExtensions::Numeric::Bytes
-  include ActiveSupport::CoreExtensions::Numeric::Conversions 
-end
+require 'active_support/core_ext/numeric/time'

data/lib/active_support/core_ext/object/acts_like.rb

@@ -0,0 +1,10 @@
+class Object
+  # A duck-type assistant method. For example, Active Support extends Date
+  # to define an acts_like_date? method, and extends Time to define
+  # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
+  # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
+  # we want to act like Time simply need to define an acts_like_time? method.
+  def acts_like?(duck)
+    respond_to? :"acts_like_#{duck}?"
+  end
+end

data/lib/active_support/core_ext/object/blank.rb

@@ -2,11 +2,11 @@ class Object
   # An object is blank if it's false, empty, or a whitespace string.
   # For example, "", "   ", +nil+, [], and {} are blank.
   #
-  # This simplifies
+  # This simplifies:
   #
   #   if !address.nil? && !address.empty?
   #
-  # to
+  # ...to:
   #
   #   if !address.blank?
   def blank?
@@ -17,6 +17,24 @@ class Object
   def present?
     !blank?
   end
+  
+  # Returns object if it's #present? otherwise returns nil.
+  # object.presence is equivalent to object.present? ? object : nil.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all.  For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
 end
 
 class NilClass #:nodoc:

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

@@ -1,15 +1,4 @@
-class Object
-  # Alias of <tt>to_s</tt>.
-  def to_param
-    to_s
-  end
-
-  # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
-  # param name.
-  #
-  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
-  def to_query(key)
-    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
-    "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
-  end
-end
+require 'active_support/core_ext/object/to_param'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/hash/conversions'

data/lib/active_support/core_ext/object/duplicable.rb

@@ -0,0 +1,65 @@
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+class Object
+  # Can you safely .dup this object?
+  # False for nil, false, true, symbols, numbers, class and module objects; true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Symbol #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Numeric #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Class #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Module #:nodoc:
+  def duplicable?
+    false
+  end
+end

data/lib/active_support/core_ext/object/extending.rb

@@ -1,80 +1,11 @@
-class Object
-  def remove_subclasses_of(*superclasses) #:nodoc:
-    Class.remove_class(*subclasses_of(*superclasses))
-  end
-
-  begin
-    ObjectSpace.each_object(Class.new) {}
-
-    # Exclude this class unless it's a subclass of our supers and is defined.
-    # We check defined? in case we find a removed class that has yet to be
-    # garbage collected. This also fails for anonymous classes -- please
-    # submit a patch if you have a workaround.
-    def subclasses_of(*superclasses) #:nodoc:
-      subclasses = []
-
-      superclasses.each do |sup|
-        ObjectSpace.each_object(class << sup; self; end) do |k|
-          if k != sup && (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
-            subclasses << k
-          end
-        end
-      end
-
-      subclasses
-    end
-  rescue RuntimeError
-    # JRuby and any implementations which cannot handle the objectspace traversal
-    # above fall back to this implementation
-    def subclasses_of(*superclasses) #:nodoc:
-      subclasses = []
-
-      superclasses.each do |sup|
-        ObjectSpace.each_object(Class) do |k|
-          if superclasses.any? { |superclass| k < superclass } &&
-            (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
-            subclasses << k
-          end
-        end
-        subclasses.uniq!
-      end
-      subclasses
-    end
-  end
+require 'active_support/core_ext/class/subclasses'
 
-  def extended_by #:nodoc:
-    ancestors = class << self; ancestors end
-    ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
-  end
-
-  def extend_with_included_modules_from(object) #:nodoc:
-    object.extended_by.each { |mod| extend mod }
-  end
-
-  unless defined? instance_exec # 1.9
-    module InstanceExecMethods #:nodoc:
-    end
-    include InstanceExecMethods
-
-    # Evaluate the block with the given arguments within the context of
-    # this object, so self is set to the method receiver.
-    #
-    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
-    def instance_exec(*args, &block)
-      begin
-        old_critical, Thread.critical = Thread.critical, true
-        n = 0
-        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
-        InstanceExecMethods.module_eval { define_method(method_name, &block) }
-      ensure
-        Thread.critical = old_critical
-      end
-
-      begin
-        send(method_name, *args)
-      ensure
-        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
-      end
-    end
+class Object
+  # Exclude this class unless it's a subclass of our supers and is defined.
+  # We check defined? in case we find a removed class that has yet to be
+  # garbage collected. This also fails for anonymous classes -- please
+  # submit a patch if you have a workaround.
+  def subclasses_of(*superclasses) #:nodoc:
+    Class.subclasses_of(*superclasses)
   end
 end

data/lib/active_support/core_ext/object/instance_variables.rb

@@ -1,11 +1,4 @@
 class Object
-  # Available in 1.8.6 and later.
-  unless respond_to?(:instance_variable_defined?)
-    def instance_variable_defined?(variable)
-      instance_variables.include?(variable.to_s)
-    end
-  end
-
   # Returns a hash that maps instance variable names without "@" to their
   # corresponding values. Keys are strings both in Ruby 1.8 and 1.9.
   #

data/lib/active_support/core_ext/object/misc.rb

@@ -1,90 +1,2 @@
-class Object
-  # Returns +value+ after yielding +value+ to the block. This simplifies the
-  # process of constructing an object, performing work on the object, and then
-  # returning the object from a method. It is a Ruby-ized realization of the K
-  # combinator, courtesy of Mikael Brockman.
-  #
-  # ==== Examples
-  #
-  #  # Without returning
-  #  def foo
-  #    values = []
-  #    values << "bar"
-  #    values << "baz"
-  #    return values
-  #  end
-  #
-  #  foo # => ['bar', 'baz']
-  #
-  #  # returning with a local variable
-  #  def foo
-  #    returning values = [] do
-  #      values << 'bar'
-  #      values << 'baz'
-  #    end
-  #  end
-  #
-  #  foo # => ['bar', 'baz']
-  #  
-  #  # returning with a block argument
-  #  def foo
-  #    returning [] do |values|
-  #      values << 'bar'
-  #      values << 'baz'
-  #    end
-  #  end
-  #  
-  #  foo # => ['bar', 'baz']
-  def returning(value)
-    yield(value)
-    value
-  end
-
-  # Yields <code>x</code> to the block, and then returns <code>x</code>.
-  # The primary purpose of this method is to "tap into" a method chain,
-  # in order to perform operations on intermediate results within the chain.
-  #
-  #   (1..10).tap { |x| puts "original: #{x.inspect}" }.to_a.
-  #     tap    { |x| puts "array: #{x.inspect}" }.
-  #     select { |x| x%2 == 0 }.
-  #     tap    { |x| puts "evens: #{x.inspect}" }.
-  #     map    { |x| x*x }.
-  #     tap    { |x| puts "squares: #{x.inspect}" }
-  def tap
-    yield self
-    self
-  end unless Object.respond_to?(:tap)
-
-  # An elegant way to factor duplication out of options passed to a series of
-  # method calls. Each method called in the block, with the block variable as
-  # the receiver, will have its options merged with the default +options+ hash
-  # provided. Each method called on the block variable must take an options
-  # hash as its final argument.
-  # 
-  #   with_options :order => 'created_at', :class_name => 'Comment' do |post|
-  #     post.has_many :comments, :conditions => ['approved = ?', true], :dependent => :delete_all
-  #     post.has_many :unapproved_comments, :conditions => ['approved = ?', false]
-  #     post.has_many :all_comments
-  #   end
-  #
-  # Can also be used with an explicit receiver:
-  #
-  #   map.with_options :controller => "people" do |people|
-  #     people.connect "/people",     :action => "index"
-  #     people.connect "/people/:id", :action => "show"
-  #   end
-  #
-  def with_options(options)
-    yield ActiveSupport::OptionMerger.new(self, options)
-  end
-  
-  # A duck-type assistant method. For example, Active Support extends Date
-  # to define an acts_like_date? method, and extends Time to define
-  # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
-  # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
-  # we want to act like Time simply need to define an acts_like_time? method.
-  def acts_like?(duck)
-    respond_to? "acts_like_#{duck}?"
-  end
-
-end
+require 'active_support/core_ext/object/returning'
+require 'active_support/core_ext/object/with_options'

data/lib/active_support/core_ext/object/returning.rb

@@ -0,0 +1,42 @@
+class Object
+  # Returns +value+ after yielding +value+ to the block. This simplifies the
+  # process of constructing an object, performing work on the object, and then
+  # returning the object from a method. It is a Ruby-ized realization of the K
+  # combinator, courtesy of Mikael Brockman.
+  #
+  # ==== Examples
+  #
+  #  # Without returning
+  #  def foo
+  #    values = []
+  #    values << "bar"
+  #    values << "baz"
+  #    return values
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  #
+  #  # returning with a local variable
+  #  def foo
+  #    returning values = [] do
+  #      values << 'bar'
+  #      values << 'baz'
+  #    end
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  #
+  #  # returning with a block argument
+  #  def foo
+  #    returning [] do |values|
+  #      values << 'bar'
+  #      values << 'baz'
+  #    end
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  def returning(value)
+    yield(value)
+    value
+  end
+end