activesupport 3.0.0.beta4 → 3.0.pre

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

@@ -0,0 +1,23 @@
+class Module
+  # Returns String#underscore applied to the module name minus trailing classes.
+  #
+  #   ActiveRecord.as_load_path               # => "active_record"
+  #   ActiveRecord::Associations.as_load_path # => "active_record/associations"
+  #   ActiveRecord::Base.as_load_path         # => "active_record" (Base is a class)
+  #
+  # The Kernel module gives an empty string by definition.
+  #
+  #   Kernel.as_load_path # => ""
+  #   Math.as_load_path   # => "math"
+  def as_load_path
+    if self == Object || self == Kernel
+      ''
+    elsif is_a? Class
+      parent == self ? '' : parent.as_load_path
+    else
+      name.split('::').collect do |word|
+        word.underscore
+      end * '/'
+    end
+  end
+end

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

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/array/extract_options'
 
 class Module
   # Synchronize access around a method, delegating synchronization to a
@@ -28,7 +27,7 @@ class Module
         raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
       end
 
-      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      module_eval(<<-EOS, __FILE__, __LINE__)
         def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
           #{with}.synchronize do                                                    #   @@lock.synchronize do
             #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)

data/lib/active_support/core_ext/name_error.rb

@@ -1,9 +1,7 @@
 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
+    $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
   end
 
   # Was this exception raised because the given name was missing?

data/lib/active_support/core_ext/nil.rb

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

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

@@ -0,0 +1,5 @@
+class NilClass
+  def to_param
+    self
+  end
+end

data/lib/active_support/core_ext/object.rb

@@ -4,11 +4,7 @@ require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/object/try'
 
 require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/object/extending'
 require 'active_support/core_ext/object/instance_variables'
+require 'active_support/core_ext/object/metaclass'
 require 'active_support/core_ext/object/misc'
-require 'active_support/core_ext/object/extending'
-
-require 'active_support/core_ext/object/returning'
-require 'active_support/core_ext/object/to_param'
-require 'active_support/core_ext/object/to_query'
-require 'active_support/core_ext/object/with_options'

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,24 +17,6 @@ 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,4 +1,18 @@
-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'
+
+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

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

@@ -1,22 +1,6 @@
-# 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.
+  # False for nil, false, true, symbols, numbers, and class objects; true otherwise.
   def duplicable?
     true
   end
@@ -57,9 +41,3 @@ class Class #:nodoc:
     false
   end
 end
-
-class Module #:nodoc:
-  def duplicable?
-    false
-  end
-end

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

@@ -1,11 +1,80 @@
-require 'active_support/core_ext/class/subclasses'
-
 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)
+  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
+
+  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
   end
 end

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

@@ -1,4 +1,11 @@
 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/metaclass.rb

@@ -0,0 +1,13 @@
+class Object
+  # Get object's meta (ghost, eigenclass, singleton) class
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  # If class_eval is called on an object, add those methods to its metaclass
+  def class_eval(*args, &block)
+    metaclass.class_eval(*args, &block)
+  end
+end

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

@@ -1,2 +1,3 @@
 require 'active_support/core_ext/object/returning'
+require 'active_support/core_ext/object/tap'
 require 'active_support/core_ext/object/with_options'

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

@@ -0,0 +1,16 @@
+class Object
+  # 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)
+end

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

@@ -1,5 +1,3 @@
-require 'active_support/option_merger'
-
 class Object
   # 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

data/lib/active_support/core_ext/proc.rb

@@ -1,13 +1,13 @@
-require "active_support/core_ext/kernel/singleton_class"
+require "active_support/core_ext/object"
 
 class Proc #:nodoc:
   def bind(object)
     block, time = self, Time.now
     object.class_eval do
       method_name = "__bind_#{time.to_i}_#{time.usec}"
-      define_method(method_name, &block)
-      method = instance_method(method_name)
-      remove_method(method_name)
+      define_method(method_name, &block)     # define_method("__bind_1230458026_720454", &block)
+      method = instance_method(method_name)  # method = instance_method("__bind_1230458026_720454")
+      remove_method(method_name)             # remove_method("__bind_1230458026_720454")
       method
     end.bind(object)
   end

data/lib/active_support/core_ext/regexp.rb

@@ -1,5 +1,27 @@
 class Regexp #:nodoc:
+  def number_of_captures
+    Regexp.new("|#{source}").match('').captures.length
+  end
+
   def multiline?
     options & MULTILINE == MULTILINE
   end
+
+  class << self
+    def optionalize(pattern)
+      return pattern if pattern == ""
+
+      case unoptionalize(pattern)
+        when /\A(.|\(.*\))\Z/ then "#{pattern}?"
+        else "(?:#{pattern})?"
+      end
+    end
+
+    def unoptionalize(pattern)
+      [/\A\(\?:(.*)\)\?\Z/, /\A(.|\(.*\))\?\Z/].each do |regexp|
+        return $1 if regexp =~ pattern
+      end
+      return pattern
+    end
+  end
 end

data/lib/active_support/core_ext/rexml.rb

@@ -2,10 +2,7 @@ require 'active_support/core_ext/kernel/reporting'
 
 # Fixes the rexml vulnerability disclosed at:
 # http://www.ruby-lang.org/en/news/2008/08/23/dos-vulnerability-in-rexml/
-# This fix is identical to rexml-expansion-fix version 1.0.1.
-#
-# We still need to distribute this fix because albeit the REXML
-# in recent 1.8.7s is patched, it wasn't in early patchlevels.
+# This fix is identical to rexml-expansion-fix version 1.0.1
 require 'rexml/rexml'
 
 # Earlier versions of rexml defined REXML::Version, newer ones REXML::VERSION

data/lib/active_support/core_ext/string.rb

@@ -4,9 +4,8 @@ require 'active_support/core_ext/string/multibyte'
 require 'active_support/core_ext/string/starts_ends_with'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/string/iterators'
 require 'active_support/core_ext/string/xchar'
 require 'active_support/core_ext/string/behavior'
 require 'active_support/core_ext/string/interpolation'
-require 'active_support/core_ext/string/output_safety'
-require 'active_support/core_ext/string/exclude'
-require 'active_support/core_ext/string/encoding'
+require 'active_support/core_ext/string/output_safety'

data/lib/active_support/core_ext/string/access.rb

@@ -1,5 +1,3 @@
-require "active_support/multibyte"
-
 class String
   unless '1.9'.respond_to?(:force_encoding)
     # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
@@ -7,7 +5,7 @@ class String
     # Examples: 
     #   "hello".at(0)  # => "h"
     #   "hello".at(4)  # => "o"
-    #   "hello".at(10) # => ERROR if < 1.9, nil in 1.9
+    #   "hello".at(10) # => nil
     def at(position)
       mb_chars[position, 1].to_s
     end
@@ -17,7 +15,7 @@ class String
     # Examples: 
     #   "hello".from(0)  # => "hello"
     #   "hello".from(2)  # => "llo"
-    #   "hello".from(10) # => "" if < 1.9, nil in 1.9
+    #   "hello".from(10) # => nil
     def from(position)
       mb_chars[position..-1].to_s
     end

data/lib/active_support/core_ext/string/bytesize.rb

@@ -0,0 +1,5 @@
+unless '1.9'.respond_to?(:bytesize)
+  class String
+    alias :bytesize :size
+  end
+end

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

@@ -1,61 +1,26 @@
 require 'date'
-require 'active_support/core_ext/time/publicize_conversion_methods'
 require 'active_support/core_ext/time/calculations'
 
 class String
-  # Returns the codepoint of the first character of the string, assuming a
-  # single-byte character encoding:
-  #
-  #   "a".ord # => 97
-  #   "à".ord # => 224, in ISO-8859-1
-  #
-  # This method is defined in Ruby 1.8 for Ruby 1.9 forward compatibility on
-  # these character encodings.
-  #
-  # <tt>ActiveSupport::Multibyte::Chars#ord</tt> is forward compatible with
-  # Ruby 1.9 on UTF8 strings:
-  #
-  #   "a".mb_chars.ord # => 97
-  #   "à".mb_chars.ord # => 224, in UTF8
-  #
-  # Note that the 224 is different in both examples. In ISO-8859-1 "à" is
-  # represented as a single byte, 224. In UTF8 it is represented with two
-  # bytes, namely 195 and 160, but its Unicode codepoint is 224. If we
-  # call +ord+ on the UTF8 string "à" the return value will be 195. That is
-  # not an error, because UTF8 is unsupported, the call itself would be
-  # bogus.
+  # 'a'.ord == 'a'[0] for Ruby 1.9 forward compatibility.
   def ord
     self[0]
   end unless method_defined?(:ord)
 
   # Form can be either :utc (default) or :local.
   def to_time(form = :utc)
-    return nil if self.blank?
     d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction).map { |arg| arg || 0 }
     d[6] *= 1000000
     ::Time.send("#{form}_time", *d)
   end
 
   def to_date
-    return nil if self.blank?
     ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
   end
 
   def to_datetime
-    return nil if self.blank?
     d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :sec_fraction).map { |arg| arg || 0 }
     d[5] += d.pop
     ::DateTime.civil(*d)
   end
-
-  # +constantize+ tries to find a declared constant with the name specified
-  # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.
-  #
-  # Examples
-  #   "Module".constantize # => Module
-  #   "Class".constantize  # => Class
-  def constantize
-    ActiveSupport::Inflector.constantize(self)
-  end
 end