activesupport 3.0.20 → 3.1.0.beta1

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

@@ -7,25 +7,24 @@ class Module
   #     attr_accessor_with_default :age, 25
   #   end
   #
-  #   some_person.age
-  #   => 25
-  #   some_person.age = 26
-  #   some_person.age
-  #   => 26
+  #   person = Person.new
+  #   person.age # => 25
+  #
+  #   person.age = 26
+  #   person.age # => 26
   #
   # To give attribute <tt>:element_name</tt> a dynamic default value, evaluated
   # in scope of self:
   #
   #   attr_accessor_with_default(:element_name) { name.underscore }
   #
-  def attr_accessor_with_default(sym, default = nil, &block)
-    raise 'Default value or block required' unless !default.nil? || block
-    define_method(sym, block_given? ? block : Proc.new { default })
+  def attr_accessor_with_default(sym, default = Proc.new)
+    define_method(sym, block_given? ? default : Proc.new { default })
     module_eval(<<-EVAL, __FILE__, __LINE__ + 1)
-      def #{sym}=(value)                        # def age=(value)
-        class << self; attr_reader :#{sym} end  #   class << self; attr_reader :age end
-        @#{sym} = value                         #   @age = value
-      end                                       # end
+      def #{sym}=(value)                          # def age=(value)
+        class << self; attr_accessor :#{sym} end  #   class << self; attr_accessor :age end
+        @#{sym} = value                           #   @age = value
+      end                                         # end
     EVAL
   end
 end

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

@@ -1,16 +1,12 @@
 class Module
   # Declares an attribute reader backed by an internally-named instance variable.
   def attr_internal_reader(*attrs)
-    attrs.each do |attr|
-      module_eval "def #{attr}() #{attr_internal_ivar_name(attr)} end", __FILE__, __LINE__
-    end
+    attrs.each {|attr_name| attr_internal_define(attr_name, :reader)}
   end
 
   # Declares an attribute writer backed by an internally-named instance variable.
   def attr_internal_writer(*attrs)
-    attrs.each do |attr|
-      module_eval "def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end", __FILE__, __LINE__
-    end
+    attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}
   end
 
   # Declares an attribute reader and writer backed by an internally-named instance
@@ -29,4 +25,15 @@ class Module
     def attr_internal_ivar_name(attr)
       Module.attr_internal_naming_format % attr
     end
+
+    def attr_internal_define(attr_name, type)
+      internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, '')
+      class_eval do # class_eval is necessary on 1.9 or else the methods a made private
+        # use native attr_* methods as they are faster on some Ruby implementations
+        send("attr_#{type}", internal_name)
+      end
+      attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
+      alias_method attr_name, internal_name
+      remove_method internal_name
+    end
 end

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

@@ -1,3 +1,5 @@
+require 'active_support/deprecation'
+
 class Module
   # Declare that a method has been deprecated.
   #   deprecate :foo

data/lib/active_support/core_ext/object.rb

@@ -2,7 +2,7 @@ require 'active_support/core_ext/object/acts_like'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/object/try'
-require 'active_support/core_ext/object/returning'
+require 'active_support/core_ext/object/inclusion'
 
 require 'active_support/core_ext/object/conversions'
 require 'active_support/core_ext/object/instance_variables'

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

@@ -13,13 +13,13 @@ class Object
     respond_to?(:empty?) ? empty? : !self
   end
 
-  # An object is present if it's not blank.
+  # An object is present if it's not <tt>blank?</tt>.
   def present?
     !blank?
   end
 
-  # Returns object if it's #present? otherwise returns nil.
-  # object.presence is equivalent to object.present? ? object : nil.
+  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
   #
   # 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
@@ -37,39 +37,72 @@ class Object
   end
 end
 
-class NilClass #:nodoc:
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
   def blank?
     true
   end
 end
 
-class FalseClass #:nodoc:
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
   def blank?
     true
   end
 end
 
-class TrueClass #:nodoc:
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
   def blank?
     false
   end
 end
 
-class Array #:nodoc:
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
   alias_method :blank?, :empty?
 end
 
-class Hash #:nodoc:
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   {:key => 'value'}.blank? # => false
+  #
   alias_method :blank?, :empty?
 end
 
-class String #:nodoc:
+class String
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   "".blank?                 # => true
+  #   "   ".blank?              # => true
+  #   " something here ".blank? # => false
+  #
   def blank?
     self !~ /\S/
   end
 end
 
 class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
   def blank?
     false
   end

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

@@ -15,50 +15,89 @@
 # 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.
+  # 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:
+class NilClass
+  # +nil+ is not duplicable:
+  #
+  #   nil.duplicable? # => false
+  #   nil.dup         # => TypeError: can't dup NilClass
+  #
   def duplicable?
     false
   end
 end
 
-class FalseClass #:nodoc:
+class FalseClass
+  # +false+ is not duplicable:
+  #
+  #   false.duplicable? # => false
+  #   false.dup         # => TypeError: can't dup FalseClass
+  #
   def duplicable?
     false
   end
 end
 
-class TrueClass #:nodoc:
+class TrueClass
+  # +true+ is not duplicable:
+  #
+  #   true.duplicable? # => false
+  #   true.dup         # => TypeError: can't dup TrueClass
+  #
   def duplicable?
     false
   end
 end
 
-class Symbol #:nodoc:
+class Symbol
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.duplicable? # => false
+  #   :my_symbol.dup         # => TypeError: can't dup Symbol
+  #
   def duplicable?
     false
   end
 end
 
-class Numeric #:nodoc:
+class Numeric
+  # Numbers are not duplicable:
+  #
+  #  3.duplicable? # => false
+  #  3.dup         # => TypeError: can't dup Fixnum
+  #
   def duplicable?
     false
   end
 end
 
-class Class #:nodoc:
+class Class
+  # Classes are not duplicable:
+  #
+  #  c = Class.new # => #<Class:0x10328fd80>
+  #  c.dup         # => #<Class:0x10328fd80>
+  #
+  # Note +dup+ returned the same class object.
   def duplicable?
     false
   end
 end
 
-class Module #:nodoc:
+class Module
+  # Modules are not duplicable:
+  #
+  #  m = Module.new # => #<Module:0x10328b6e0>
+  #  m.dup          # => #<Module:0x10328b6e0>
+  #
+  # Note +dup+ returned the same module object.
   def duplicable?
     false
   end

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

@@ -0,0 +1,15 @@
+class Object
+  # Returns true if this object is included in the argument. Argument must be
+  # any object which responds to +#include?+. Usage:
+  #
+  #   characters = ["Konata", "Kagami", "Tsukasa"]
+  #   "Konata".in?(characters) # => true
+  #
+  # This will throw an ArgumentError if the argument doesn't respond
+  # to +#include?+.
+  def in?(another_object)
+    another_object.include?(self)
+  rescue NoMethodError
+    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
+  end
+end

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

@@ -10,10 +10,7 @@ class Object
   #
   #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
   def instance_values #:nodoc:
-    instance_variables.inject({}) do |values, name|
-      values[name.to_s[1..-1]] = instance_variable_get(name)
-      values
-    end
+    Hash[instance_variables.map { |name| [name.to_s[1..-1], instance_variable_get(name)] }]
   end
 
   # Returns an array of instance variable names including "@". They are strings
@@ -33,35 +30,4 @@ class Object
   else
     alias_method :instance_variable_names, :instance_variables
   end
-
-  # Copies the instance variables of +object+ into +self+.
-  #
-  # Instance variable names in the +exclude+ array are ignored. If +object+
-  # responds to <tt>protected_instance_variables</tt> the ones returned are
-  # also ignored. For example, Rails controllers implement that method.
-  #
-  # In both cases strings and symbols are understood, and they have to include
-  # the at sign.
-  #
-  #   class C
-  #     def initialize(x, y, z)
-  #       @x, @y, @z = x, y, z
-  #     end
-  #
-  #     def protected_instance_variables
-  #       %w(@z)
-  #     end
-  #   end
-  #
-  #   a = C.new(0, 1, 2)
-  #   b = C.new(3, 4, 5)
-  #
-  #   a.copy_instance_variables_from(b, [:@y])
-  #   # a is now: @x = 3, @y = 1, @z = 2
-  def copy_instance_variables_from(object, exclude = []) #:nodoc:
-    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
-
-    vars = object.instance_variables.map(&:to_s) - exclude.map(&:to_s)
-    vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
-  end
 end

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

@@ -1,5 +1,3 @@
-
-
 class Object
   # Alias of <tt>to_s</tt>.
   def to_param
@@ -34,14 +32,21 @@ class Array
 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). The string pairs "key=value" that conform the query
-  # string are sorted lexicographically in ascending order.
+  # Returns a string representation of the receiver suitable for use as a URL
+  # query string:
+  #
+  #   {:name => 'David', :nationality => 'Danish'}.to_param
+  #   # => "name=David&nationality=Danish"
+  #
+  # An optional namespace can be passed to enclose the param names:
+  #
+  #   {:name => 'David', :nationality => 'Danish'}.to_param('user')
+  #   # => "user[name]=David&user[nationality]=Danish"
   #
-  # ==== Examples
-  #   { :name => 'David', :nationality => 'Danish' }.to_param # => "name=David&nationality=Danish"
+  # The string pairs "key=value" that conform the query string
+  # are sorted lexicographically in ascending order.
   #
-  #   { :name => 'David', :nationality => 'Danish' }.to_param('user') # => "user[name]=David&user[nationality]=Danish"
+  # This method is also aliased as +to_query+.
   def to_param(namespace = nil)
     collect do |key, value|
       value.to_query(namespace ? "#{namespace}[#{key}]" : key)

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

@@ -7,7 +7,7 @@ class Object
   # 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)}"
+    "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
   end
 end
 
@@ -15,7 +15,7 @@ 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"
+  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
   def to_query(key)
     prefix = "#{key}[]"
     collect { |value| value.to_query(prefix) }.join '&'

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

@@ -5,31 +5,48 @@ class Object
   # *Unlike* that method however, a +NoMethodError+ exception will *not* be raised
   # and +nil+ will be returned instead, if the receiving object is a +nil+ object or NilClass.
   #
+  # If try is called without a method to call, it will yield any given block with the object.
+  #
   # ==== Examples
   #
-  # Without try
+  # Without +try+
   #   @person && @person.name
   # or
   #   @person ? @person.name : nil
   #
-  # With try
+  # With +try+
   #   @person.try(:name)
   #
   # +try+ also accepts arguments and/or a block, for the method it is trying
   #   Person.try(:find, 1)
   #   @people.try(:collect) {|p| p.name}
+  #
+  # Without a method argument try will yield to the block unless the receiver is nil.
+  #   @person.try { |p| "#{p.first_name} #{p.last_name}" }
   #--
-  # This method definition below is for rdoc purposes only. The alias_method call
-  # below overrides it as an optimization since +try+ behaves like +Object#send+,
-  # unless called on +NilClass+.
-  def try(method, *args, &block)
-    send(method, *args, &block)
+  # +try+ behaves like +Object#send+, unless called on +NilClass+.
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      __send__(*a, &b)
+    end
   end
-  remove_method :try
-  alias_method :try, :__send__
 end
 
-class NilClass #:nodoc:
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes specially helpful when navigating through associations that may return +nil+.
+  #
+  # === Examples
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && !@person.children.blank? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
   def try(*args)
     nil
   end