activesupport 3.0.20 → 3.1.0.beta1

data/lib/active_support/concern.rb

@@ -1,39 +1,109 @@
-# A typical module looks like this
-#
-#   module M
-#     def self.included(base)
-#       base.send(:extend, ClassMethods)
-#       base.send(:include, InstanceMethods)
-#       scope :foo, :conditions => { :created_at => nil }
-#     end
-#
-#     module ClassMethods
-#       def cm; puts 'I am a class method'; end
-#     end
-#
-#     module InstanceMethods
-#       def im; puts 'I am an instance method'; end
-#     end
-#   end
-#
-# By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
-#
-#   module M
-#     extend ActiveSupport::Concern
-#
-#     included do
-#       scope :foo, :conditions => { :created_at => nil }
-#     end
-#
-#     module ClassMethods
-#       def cm; puts 'I am a class method'; end
-#     end
-#
-#     module InstanceMethods
-#       def im; puts 'I am an instance method'; end
-#     end
-#   end
 module ActiveSupport
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.send(:include, InstanceMethods)
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #
+  #     module InstanceMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #
+  #     module InstanceMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module and a +Bar+
+  # module which depends on the former, we would typically write the following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We could try to hide
+  # these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo 
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt> is the +Bar+ module,
+  # not the +Host+ class. With <tt>ActiveSupport::Concern</tt>, module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # works, Bar takes care now of its dependencies
+  #   end
+  #
   module Concern
     def self.extended(base)
       base.instance_variable_set("@_dependencies", [])

data/lib/active_support/configurable.rb

@@ -4,12 +4,34 @@ require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/delegation'
 
 module ActiveSupport
+  # Configurable provides a <tt>config</tt> method to store and retrieve
+  # configuration options as an <tt>OrderedHash</tt>.
   module Configurable
     extend ActiveSupport::Concern
 
+    class Configuration < ActiveSupport::InheritableOptions
+      def compile_methods!
+        self.class.compile_methods!(keys.reject {|key| respond_to?(key)})
+      end
+
+      # compiles reader methods so we don't have to go through method_missing
+      def self.compile_methods!(keys)
+        keys.each do |key|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{key}; _get(#{key.inspect}); end
+          RUBY
+        end
+      end
+    end
+
     module ClassMethods
       def config
-        @_config ||= ActiveSupport::InheritableOptions.new(superclass.respond_to?(:config) ? superclass.config : {})
+        @_config ||= if respond_to?(:superclass) && superclass.respond_to?(:config)
+          superclass.config.inheritable_copy
+        else
+          # create a new "anonymous" class that will host the compiled reader methods
+          Class.new(Configuration).new
+        end
       end
 
       def configure
@@ -41,8 +63,25 @@ module ActiveSupport
       end
     end
 
+    # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.
+    #
+    #   require 'active_support/configurable'
+    #
+    #   class User
+    #     include ActiveSupport::Configurable
+    #   end
+    #
+    #   user = User.new
+    #
+    #   user.config.allowed_access = true
+    #   user.config.level = 1
+    #
+    #   user.config.allowed_access # => true
+    #   user.config.level          # => 1
+    #
     def config
-      @_config ||= ActiveSupport::InheritableOptions.new(self.class.config)
+      @_config ||= self.class.config.inheritable_copy
     end
   end
 end
+

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

@@ -3,10 +3,10 @@ class Array
   #
   #   %w( a b c d ).from(0)  # => %w( a b c d )
   #   %w( a b c d ).from(2)  # => %w( c d )
-  #   %w( a b c d ).from(10) # => nil
+  #   %w( a b c d ).from(10) # => %w()
   #   %w().from(0)           # => %w()
   def from(position)
-    self[position..-1]
+    self[position, length] || []
   end
 
   # Returns the beginning of the array up to +position+.

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

@@ -1,12 +1,15 @@
 class Array
-  # Backport of Array#sample based on Marc-Andre Lafortune's http://github.com/marcandre/backports/
+  # Backport of Array#sample based on Marc-Andre Lafortune's https://github.com/marcandre/backports/
   # Returns a random element or +n+ random elements from the array.
-  # If the array is empty and +n+ is nil, returns <tt>nil</tt>. if +n+ is passed, returns <tt>[]</tt>.
+  # If the array is empty and +n+ is nil, returns <tt>nil</tt>.
+  # If +n+ is passed and its value is less than 0, it raises an +ArgumentError+ exception.
+  # If the value of +n+ is equal or greater than 0 it returns <tt>[]</tt>.
   #
-  #   [1,2,3,4,5,6].sample    # => 4
-  #   [1,2,3,4,5,6].sample(3) # => [2, 4, 5]
-  #              [].sample    # => nil
-  #              [].sample(3) # => []
+  #   [1,2,3,4,5,6].sample     # => 4
+  #   [1,2,3,4,5,6].sample(3)  # => [2, 4, 5]
+  #   [1,2,3,4,5,6].sample(-3) # => ArgumentError: negative sample number
+  #              [].sample     # => nil
+  #              [].sample(3)  # => []
   def sample(n=nil)
     return self[Kernel.rand(size)] if n.nil?
     n = n.to_int
@@ -24,4 +27,4 @@ class Array
     result[n..size] = []
     result
   end unless method_defined? :sample
-end
+end

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

@@ -11,8 +11,6 @@ class BigDecimal
   YAML_TAG = 'tag:yaml.org,2002:float'
   YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
 
-  yaml_as YAML_TAG
-
   # This emits the number without any scientific notation.
   # This is better than self.to_f.to_s since it doesn't lose precision.
   #

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

@@ -1,6 +1,5 @@
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/array/extract_options'
 
 class Class
   # Declare a class-level attribute whose value is inheritable by subclasses.
@@ -57,18 +56,11 @@ class Class
   #   object.setting          # => false
   #   Base.setting            # => true
   #
-  # To opt out of the instance reader method, pass :instance_reader => false.
-  #
-  #   object.setting          # => NoMethodError
-  #   object.setting?         # => NoMethodError
-  #
   # To opt out of the instance writer method, pass :instance_writer => false.
   #
   #   object.setting = false  # => NoMethodError
   def class_attribute(*attrs)
-    options = attrs.extract_options!
-    instance_reader = options.fetch(:instance_reader, true)
-    instance_writer = options.fetch(:instance_writer, true)
+    instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]
 
     attrs.each do |name|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -80,22 +72,40 @@ class Class
             remove_possible_method(:#{name})
             define_method(:#{name}) { val }
           end
+
+          if singleton_class?
+            class_eval do
+              remove_possible_method(:#{name})
+              def #{name}
+                defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+              end
+            end
+          end
           val
         end
 
-        if instance_reader
-          remove_possible_method :#{name}
-          def #{name}
-            defined?(@#{name}) ? @#{name} : singleton_class.#{name}
-          end
+        remove_possible_method :#{name}
+        def #{name}
+          defined?(@#{name}) ? @#{name} : self.class.#{name}
+        end
 
-          def #{name}?
-            !!#{name}
-          end
+        def #{name}?
+          !!#{name}
         end
       RUBY
 
       attr_writer name if instance_writer
     end
   end
+
+  private
+  def singleton_class?
+    # in case somebody is crazy enough to overwrite allocate
+    allocate = Class.instance_method(:allocate)
+    # object.class always points to a real (non-singleton) class
+    allocate.bind(self).call.class != self
+  rescue TypeError
+    # MRI/YARV/JRuby all disallow creating new instances of a singleton class
+    true
+  end
 end

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

@@ -1,8 +1,10 @@
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/deprecation'
 
 # Retained for backward compatibility.  Methods are now included in Class.
 module ClassInheritableAttributes # :nodoc:
+  DEPRECATION_WARNING_MESSAGE = "class_inheritable_attribute is deprecated, please use class_attribute method instead. Notice their behavior are slightly different, so refer to class_attribute documentation first"
 end
 
 # It is recommended to use <tt>class_attribute</tt> over methods defined in this file. Please
@@ -36,6 +38,7 @@ end
 #   Person.new.hair_colors             # => NoMethodError
 class Class # :nodoc:
   def class_inheritable_reader(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       next if sym.is_a?(Hash)
@@ -54,6 +57,7 @@ class Class # :nodoc:
   end
 
   def class_inheritable_writer(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -71,6 +75,7 @@ class Class # :nodoc:
   end
 
   def class_inheritable_array_writer(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -88,6 +93,7 @@ class Class # :nodoc:
   end
 
   def class_inheritable_hash_writer(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -124,6 +130,7 @@ class Class # :nodoc:
   end
 
   def write_inheritable_attribute(key, value)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
       @inheritable_attributes = {}
     end
@@ -141,10 +148,12 @@ class Class # :nodoc:
   end
 
   def read_inheritable_attribute(key)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     inheritable_attributes[key]
   end
 
   def reset_inheritable_attributes
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
   end
 
@@ -158,9 +167,9 @@ class Class # :nodoc:
       if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
         new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
       else
-        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
-          memo.update(key => value.duplicable? ? value.dup : value)
-        end
+        new_inheritable_attributes = Hash[inheritable_attributes.map do |(key, value)|
+          [key, value.duplicable? ? value.dup : value]
+        end]
       end
 
       child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
@@ -169,86 +178,3 @@ class Class # :nodoc:
     alias inherited_without_inheritable_attributes inherited
     alias inherited inherited_with_inheritable_attributes
 end
-
-class Class
-  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
-  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
-  #
-  # @api public
-  #
-  # @todo Do we want to block instance_reader via :instance_reader => false
-  # @todo It would be preferable that we do something with a Hash passed in
-  #   (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!
-
-    ivars.each do |ivar|
-      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{ivar}
-          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
-        end
-      RUBY
-      unless options[: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
-
-  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
-  #   define inheritable writer for.
-  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
-  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
-  #
-  # @api public
-  #
-  # @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!
-
-    ivars.each do |ivar|
-      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{ivar}=(obj)
-          @#{ivar} = obj
-        end
-      RUBY
-      unless options[:instance_writer] == false
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{ivar}=(obj) self.class.#{ivar} = obj end
-        RUBY
-      end
-
-      self.send("#{ivar}=", yield) if block_given?
-    end
-  end
-
-  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
-  #   define inheritable accessor for.
-  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
-  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
-  #
-  # @api public
-  def extlib_inheritable_accessor(*syms, &block)
-    extlib_inheritable_reader(*syms)
-    extlib_inheritable_writer(*syms, &block)
-  end
-end