activesupport 3.0.pre → 3.0.0.rc

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

@@ -1,14 +1,21 @@
+require "active_support/core_ext/module/remove_method"
+
 class Module
   # Provides a delegate class method to easily expose contained objects' methods
   # as your own. Pass one or more methods (specified as symbols or strings)
-  # and the name of the target object as the final <tt>:to</tt> option (also a symbol
-  # or string).  At least one method and the <tt>:to</tt> option are required.
+  # and the name of the target object via the <tt>:to</tt> option (also a symbol
+  # or string). At least one method and the <tt>:to</tt> option are required.
   #
   # Delegation is particularly useful with Active Record associations:
   #
   #   class Greeter < ActiveRecord::Base
-  #     def hello()   "hello"   end
-  #     def goodbye() "goodbye" end
+  #     def hello
+  #       "hello"
+  #     end
+  #
+  #     def goodbye
+  #       "goodbye"
+  #     end
   #   end
   #
   #   class Foo < ActiveRecord::Base
@@ -34,7 +41,7 @@ class Module
   #   class Foo
   #     CONSTANT_ARRAY = [0,1,2,3]
   #     @@class_array  = [4,5,6,7]
-  #     
+  #
   #     def initialize
   #       @instance_array = [8,9,10,11]
   #     end
@@ -72,9 +79,9 @@ class Module
   #   invoice.customer_name    # => "John Doe"
   #   invoice.customer_address # => "Vimmersvej 13"
   #
-  # If the object to which you delegate can be nil, you may want to use the
-  # :allow_nil option. In that case, it returns nil instead of raising a
-  # NoMethodError exception:
+  # If the delegate object is +nil+ an exception is raised, and that happens
+  # no matter whether +nil+ responds to the delegated method. You can get a
+  # +nil+ instead with the +:allow_nil+ option.
   #
   #  class Foo
   #    attr_accessor :bar
@@ -119,12 +126,16 @@ class Module
           %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
         end
 
-      module_eval(<<-EOS, file, line)
+      module_eval(<<-EOS, file, line - 5)
+        if instance_methods(false).map(&:to_s).include?("#{prefix}#{method}")
+          remove_possible_method("#{prefix}#{method}")
+        end
+
         def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
           #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
         rescue NoMethodError                                # rescue NoMethodError
           if #{to}.nil?                                     #   if client.nil?
-            #{on_nil}
+            #{on_nil}                                       #     return # depends on :allow_nil
           else                                              #   else
             raise                                           #     raise
           end                                               #   end

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

@@ -3,7 +3,7 @@ require 'active_support/inflector'
 class Module
   # Returns the name of the module containing this one.
   #
-  #   p M::N.parent_name # => "M"
+  #   M::N.parent_name # => "M"
   def parent_name
     unless defined? @parent_name
       @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
@@ -19,13 +19,13 @@ class Module
   #   end
   #   X = M::N
   #
-  #   p M::N.parent # => M
-  #   p X.parent    # => M
+  #   M::N.parent # => M
+  #   X.parent    # => M
   #
   # The parent of top-level and anonymous modules is Object.
   #
-  #   p M.parent          # => Object
-  #   p Module.new.parent # => Object
+  #   M.parent          # => Object
+  #   Module.new.parent # => Object
   #
   def parent
     parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
@@ -40,9 +40,9 @@ class Module
   #   end
   #   X = M::N
   #
-  #   p M.parents    # => [Object]
-  #   p M::N.parents # => [M, Object]
-  #   p X.parents    # => [M, Object]
+  #   M.parents    # => [Object]
+  #   M::N.parents # => [M, Object]
+  #   X.parents    # => [M, Object]
   #
   def parents
     parents = []

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

@@ -0,0 +1,14 @@
+class Module
+  if instance_methods[0].is_a?(Symbol)
+    def instance_method_names(*args)
+      instance_methods(*args).map(&:to_s)
+    end
+
+    def method_names(*args)
+      methods(*args).map(&:to_s)
+    end
+  else
+    alias_method :instance_method_names, :instance_methods
+    alias_method :method_names, :methods
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/string/inflections'
+
+class Module
+  def reachable? #:nodoc:
+    !anonymous? && name.constantize.equal?(self)
+  rescue NameError
+    false
+  end
+end

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

@@ -0,0 +1,11 @@
+class Module
+  def remove_possible_method(method)
+    remove_method(method)
+  rescue NameError
+  end
+  
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end

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

@@ -1,4 +1,5 @@
 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
@@ -27,7 +28,7 @@ class Module
         raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
       end
 
-      module_eval(<<-EOS, __FILE__, __LINE__)
+      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
         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,7 +1,9 @@
 class NameError
   # Extract the name of the missing constant from the exception message.
   def missing_name
-    $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
+    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?

data/lib/active_support/core_ext/object.rb

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

@@ -0,0 +1,19 @@
+# Hack to load json gem first so we can overwrite its to_json.
+begin
+  require 'json'
+rescue LoadError
+end
+
+# The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
+# their default behavior. That said, we need to define the basic to_json method in all of them,
+# otherwise they will always use to_json gem implementation, which is backwards incompatible in
+# several cases (for instance, the JSON implementation for Hash does not work) with inheritance
+# and consequently classes as ActiveSupport::OrderedHash cannot be serialized to json.
+[Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].each do |klass|
+  klass.class_eval <<-RUBY, __FILE__, __LINE__
+    # Dumps object in JSON (JavaScript Object Notation). See www.json.org for more info.
+    def to_json(options = nil)
+      ActiveSupport::JSON.encode(self, options)
+    end
+  RUBY
+end

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

@@ -0,0 +1,49 @@
+
+
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+end
+
+class NilClass
+  def to_param
+    self
+  end
+end
+
+class TrueClass
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  def to_param
+    self
+  end
+end
+
+class Array
+  # Calls <tt>to_param</tt> on all its elements and joins the result with
+  # slashes. This is used by <tt>url_for</tt> in Action Pack.
+  def to_param
+    collect { |e| e.to_param }.join '/'
+  end
+end
+
+class Hash
+  # Converts a hash into a string suitable for use as a URL query string. An optional <tt>namespace</tt> can be
+  # passed to enclose the param names (see example below).
+  #
+  # ==== Examples
+  #   { :name => 'David', :nationality => 'Danish' }.to_param # => "name=David&nationality=Danish"
+  #
+  #   { :name => 'David', :nationality => 'Danish' }.to_param('user') # => "user[name]=David&user[nationality]=Danish"
+  def to_param(namespace = nil)
+    collect do |key, value|
+      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+    end * '&'
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'active_support/core_ext/object/to_param'
+
+class Object
+  # 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).gsub(/%(5B|5D)/n) { [$1].pack('H*') }}=#{CGI.escape(to_param.to_s)}"
+  end
+end
+
+class Array
+  # Converts an array into a string suitable for use as a URL query string,
+  # using the given +key+ as the param name.
+  #
+  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies[]=Rails&hobbies[]=coding"
+  def to_query(key)
+    prefix = "#{key}[]"
+    collect { |value| value.to_query(prefix) }.join '&'
+  end
+end
+
+class Hash
+  alias_method :to_query, :to_param
+end

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

@@ -1,3 +1,5 @@
+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/object"
+require "active_support/core_ext/kernel/singleton_class"
 
 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)     # 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")
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
       method
     end.bind(object)
   end

data/lib/active_support/core_ext/range/overlaps.rb

@@ -1,5 +1,5 @@
 class Range
-  # Compare two ranges and see if they overlap eachother
+  # Compare two ranges and see if they overlap each other
   #  (1..5).overlaps?(4..6) # => true
   #  (1..5).overlaps?(7..9) # => false
   def overlaps?(other)

data/lib/active_support/core_ext/regexp.rb

@@ -1,27 +1,5 @@
 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