activesupport 3.0.pre → 3.0.0.rc

data/lib/active_support/callbacks.rb

@@ -1,6 +1,8 @@
+require 'active_support/descendants_tracker'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/class/inheritable_attributes'
 require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/kernel/singleton_class'
 
 module ActiveSupport
   # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
@@ -83,6 +85,10 @@ module ActiveSupport
   module Callbacks
     extend Concern
 
+    included do
+      extend ActiveSupport::DescendantsTracker
+    end
+
     def run_callbacks(kind, *args, &block)
       send("_run_#{kind}_callbacks", *args, &block)
     end
@@ -90,7 +96,7 @@ module ActiveSupport
     class Callback
       @@_callback_sequence = 0
 
-      attr_accessor :chain, :filter, :kind, :options, :per_key, :klass
+      attr_accessor :chain, :filter, :kind, :options, :per_key, :klass, :raw_filter
 
       def initialize(chain, filter, kind, options, klass)
         @chain, @kind, @klass = chain, kind, klass
@@ -202,8 +208,8 @@ module ActiveSupport
             # end
             #
             name = "_conditional_callback_#{@kind}_#{next_id}"
-            txt, line = <<-RUBY_EVAL, __LINE__ + 1
-              def #{name}(halted)
+            @klass.class_eval <<-RUBY_EVAL,  __FILE__, __LINE__ + 1
+               def #{name}(halted)
                 #{@compiled_options[0] || "if true"} && !halted
                   #{@filter} do
                     yield self
@@ -213,7 +219,6 @@ module ActiveSupport
                 end
               end
             RUBY_EVAL
-            @klass.class_eval(txt, __FILE__, line)
             "#{name}(halted) do"
           end
         end
@@ -311,9 +316,9 @@ module ActiveSupport
 
       def _normalize_legacy_filter(kind, filter)
         if !filter.respond_to?(kind) && filter.respond_to?(:filter)
-          filter.metaclass.class_eval(
-            "def #{kind}(context, &block) filter(context, &block) end",
-            __FILE__, __LINE__ - 1)
+          filter.singleton_class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            def #{kind}(context, &block) filter(context, &block) end
+          RUBY_EVAL
         elsif filter.respond_to?(:before) && filter.respond_to?(:after) && kind == :around
           def filter.around(context)
             should_continue = before(context)
@@ -367,12 +372,6 @@ module ActiveSupport
         method << "halted ? false : (block_given? ? value : true)"
         method.compact.join("\n")
       end
-
-      def clone(klass)
-        chain = CallbackChain.new(@name, @config.dup)
-        callbacks = map { |c| c.clone(chain, klass) }
-        chain.push(*callbacks)
-      end
     end
 
     module ClassMethods
@@ -391,26 +390,24 @@ module ActiveSupport
       def __define_runner(symbol) #:nodoc:
         body = send("_#{symbol}_callbacks").compile(nil)
 
-        body, line = <<-RUBY_EVAL, __LINE__
-          def _run_#{symbol}_callbacks(key = nil, &blk)
-            if key
-              name = "_run__\#{self.class.name.hash.abs}__#{symbol}__\#{key.hash.abs}__callbacks"
+        silence_warnings do
+          undef_method "_run_#{symbol}_callbacks" if method_defined?("_run_#{symbol}_callbacks")
+          class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            def _run_#{symbol}_callbacks(key = nil, &blk)
+              if key
+                name = "_run__\#{self.class.name.hash.abs}__#{symbol}__\#{key.hash.abs}__callbacks"
 
-              unless respond_to?(name)
-                self.class.__create_keyed_callback(name, :#{symbol}, self, &blk)
-              end
+                unless respond_to?(name)
+                  self.class.__create_keyed_callback(name, :#{symbol}, self, &blk)
+                end
 
-              send(name, &blk)
-            else
-              #{body}
+                send(name, &blk)
+              else
+                #{body}
+              end
             end
-          end
-          private :_run_#{symbol}_callbacks
-        RUBY_EVAL
-
-        silence_warnings do
-          undef_method "_run_#{symbol}_callbacks" if method_defined?("_run_#{symbol}_callbacks")
-          class_eval body, __FILE__, line
+            private :_run_#{symbol}_callbacks
+          RUBY_EVAL
         end
       end
 
@@ -435,10 +432,11 @@ module ActiveSupport
         options = filters.last.is_a?(Hash) ? filters.pop : {}
         filters.unshift(block) if block
 
-        chain = send("_#{name}_callbacks")
-        yield chain, type, filters, options if block_given?
-
-        __define_runner(name)
+        ([self] + ActiveSupport::DescendantsTracker.descendants(self)).each do |target|
+          chain = target.send("_#{name}_callbacks")
+          yield chain, type, filters, options
+          target.__define_runner(name)
+        end
       end
 
       # Set callbacks for a previously defined callback.
@@ -451,11 +449,13 @@ module ActiveSupport
       # Use skip_callback to skip any defined one.
       #
       # When creating or skipping callbacks, you can specify conditions that
-      # are always the same for a given key. For instance, in ActionPack,
+      # are always the same for a given key. For instance, in Action Pack,
       # we convert :only and :except conditions into per-key conditions.
       #
       #   before_filter :authenticate, :except => "index"
+      #
       # becomes
+      #
       #   dispatch_callback :before, :authenticate, :per_key => {:unless => proc {|c| c.action_name == "index"}}
       #
       # Per-Key conditions are evaluated only once per use of a given key.
@@ -467,31 +467,36 @@ module ActiveSupport
       # method that took into consideration the per_key conditions. This
       # is a speed improvement for ActionPack.
       #
-      def set_callback(name, *filters, &block)
-        __update_callbacks(name, filters, block) do |chain, type, filters, options|
-          filters.map! do |filter|
-            chain.delete_if {|c| c.matches?(type, filter) }
+      def set_callback(name, *filter_list, &block)
+        mapped = nil
+
+        __update_callbacks(name, filter_list, block) do |chain, type, filters, options|
+          mapped ||= filters.map do |filter|
             Callback.new(chain, filter, type, options.dup, self)
           end
 
-          options[:prepend] ? chain.unshift(*filters) : chain.push(*filters)
+          filters.each do |filter|
+            chain.delete_if {|c| c.matches?(type, filter) } 
+          end
+
+          options[:prepend] ? chain.unshift(*mapped) : chain.push(*mapped)
         end
       end
 
       # Skip a previously defined callback for a given type.
       #
-      def skip_callback(name, *filters, &block)
-        __update_callbacks(name, filters, block) do |chain, type, filters, options|
-          chain = send("_#{name}_callbacks=", chain.clone(self))
-
+      def skip_callback(name, *filter_list, &block)
+        __update_callbacks(name, filter_list, block) do |chain, type, filters, options|
           filters.each do |filter|
             filter = chain.find {|c| c.matches?(type, filter) }
 
             if filter && options.any?
-              filter.recompile!(options, options[:per_key] || {})
-            else
-              chain.delete(filter)
+              new_filter = filter.clone(chain, self)
+              chain.insert(chain.index(filter), new_filter)
+              new_filter.recompile!(options, options[:per_key] || {})
             end
+
+            chain.delete(filter)
           end
         end
       end
@@ -499,61 +504,85 @@ module ActiveSupport
       # Reset callbacks for a given type.
       #
       def reset_callbacks(symbol)
-        send("_#{symbol}_callbacks").clear
+        callbacks = send("_#{symbol}_callbacks")
+
+        ActiveSupport::DescendantsTracker.descendants(self).each do |target|
+          chain = target.send("_#{symbol}_callbacks")
+          callbacks.each { |c| chain.delete(c) }
+          target.__define_runner(symbol)
+        end
+
+        callbacks.clear
         __define_runner(symbol)
       end
 
-      # Define callbacks types.
-      #
-      # ==== Example
+      # Defines callbacks types:
       #
       #   define_callbacks :validate
       #
-      # ==== Options
+      # This macro accepts the following options:
       #
       # * <tt>:terminator</tt> - Indicates when a before filter is considered
       # to be halted.
       #
       #   define_callbacks :validate, :terminator => "result == false"
       #
-      # In the example above, if any before validate callbacks returns false,
-      # other callbacks are not executed. Defaults to "false".
+      # In the example above, if any before validate callbacks returns +false+,
+      # other callbacks are not executed. Defaults to "false", meaning no value
+      # halts the chain.
       #
       # * <tt>:rescuable</tt> - By default, after filters are not executed if
-      # the given block or an before_filter raises an error. Supply :rescuable => true
-      # to change this behavior.
+      # the given block or a before filter raises an error. Set this option to
+      # true to change this behavior.
+      #
+      # * <tt>:scope</tt> - Indicates which methods should be executed when a class
+      # is given as callback. Defaults to <tt>[:kind]</tt>.
       #
-      # * <tt>:scope</tt> - Show which methods should be executed when a class
-      # is giben as callback:
+      #  class Audit
+      #    def before(caller)
+      #      puts 'Audit: before is called'
+      #    end
       #
-      #   define_callbacks :filters, :scope => [ :kind ]
+      #    def before_save(caller)
+      #      puts 'Audit: before_save is called'
+      #    end
+      #  end
       #
-      # When a class is given:
+      #  class Account
+      #    include ActiveSupport::Callbacks
       #
-      #   before_filter MyFilter
+      #    define_callbacks :save
+      #    set_callback :save, :before, Audit.new
       #
-      # It will call the type of the filter in the given class, which in this
-      # case, is "before".
+      #    def save
+      #      run_callbacks :save do
+      #        puts 'save in main'
+      #      end
+      #    end
+      #  end
       #
-      # If, for instance, you supply the given scope:
+      # In the above case whenever you save an account the method <tt>Audit#before</tt> will
+      # be called. On the other hand
       #
-      #   define_callbacks :validate, :scope => [ :kind, :name ]
+      #   define_callbacks :save, :scope => [:kind, :name]
       #
-      # It will call "#{kind}_#{name}" in the given class. So "before_validate"
-      # will be called in the class below:
+      # would trigger <tt>Audit#before_save</tt> instead. That's constructed by calling
+      # <tt>"#{kind}_#{name}"</tt> on the given instance. In this case "kind" is "before" and
+      # "name" is "save".
       #
-      #   before_validate MyValidation
+      # A declaration like
       #
-      # Defaults to :kind.
+      #   define_callbacks :save, :scope => [:name]
       #
-      def define_callbacks(*symbols)
-        config = symbols.last.is_a?(Hash) ? symbols.pop : {}
-        symbols.each do |symbol|
-          extlib_inheritable_accessor("_#{symbol}_callbacks") do
-            CallbackChain.new(symbol, config)
+      # would call <tt>Audit#save</tt>.
+      #
+      def define_callbacks(*callbacks)
+        config = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
+        callbacks.each do |callback|
+          extlib_inheritable_reader("_#{callback}_callbacks") do
+            CallbackChain.new(callback, config)
           end
-
-          __define_runner(symbol)
+          __define_runner(callback)
         end
       end
     end

data/lib/active_support/configurable.rb

@@ -1,35 +1,36 @@
-require "active_support/concern"
+require 'active_support/concern'
+require 'active_support/ordered_options'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/delegation'
 
 module ActiveSupport
   module Configurable
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def get_config
-        module_parts = name.split("::")
-        modules = [Object]
-        module_parts.each {|name| modules.push modules.last.const_get(name) }
-        modules.reverse_each do |mod|
-          return mod.const_get(:DEFAULT_CONFIG) if const_defined?(:DEFAULT_CONFIG)
-        end
-        {}
-      end
-      
       def config
-        self.config = get_config unless @config
-        @config
+        @config ||= ActiveSupport::InheritableOptions.new(superclass.respond_to?(:config) ? superclass.config : {})
       end
 
-      def config=(hash)
-        @config = ActiveSupport::OrderedOptions.new
-        hash.each do |key, value|
-          @config[key] = value
+      def configure
+        yield config
+      end
+
+      def config_accessor(*names)
+        names.each do |name|
+          code, line = <<-RUBY, __LINE__ + 1
+            def #{name}; config.#{name}; end
+            def #{name}=(value); config.#{name} = value; end
+          RUBY
+
+          singleton_class.class_eval code, __FILE__, line
+          class_eval code, __FILE__, line
         end
       end
     end
 
     def config
-      self.class.config
+      @config ||= ActiveSupport::InheritableOptions.new(self.class.config)
     end
   end
 end

data/lib/active_support/core_ext/array.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/array/access'
+require 'active_support/core_ext/array/uniq_by'
 require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/array/grouping'

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

@@ -4,7 +4,7 @@ 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().from(0)           # => nil
+  #   %w().from(0)           # => %w()
   def from(position)
     self[position..-1]
   end

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

@@ -1,6 +1,7 @@
+require 'active_support/xml_mini'
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/inflector'
+require 'active_support/core_ext/string/inflections'
 
 class Array
   # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
@@ -8,21 +9,14 @@ class Array
   # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
   # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
   def to_sentence(options = {})
-    default_words_connector     = I18n.translate(:'support.array.words_connector',     :locale => options[:locale])
-    default_two_words_connector = I18n.translate(:'support.array.two_words_connector', :locale => options[:locale])
-    default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])
-
-    # Try to emulate to_sentences previous to 2.3
-    if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
-      ::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
-      ::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma
-
-      skip_last_comma = options.delete :skip_last_comma
-      if connector = options.delete(:connector)
-        options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
-      else
-        options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
-      end
+    if defined?(I18n)
+      default_words_connector     = I18n.translate(:'support.array.words_connector',     :locale => options[:locale])
+      default_two_words_connector = I18n.translate(:'support.array.two_words_connector', :locale => options[:locale])
+      default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])
+    else
+      default_words_connector     = ", "
+      default_two_words_connector = " and "
+      default_last_word_connector = ", and "
     end
 
     options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
@@ -40,22 +34,6 @@ class Array
     end
   end
 
-
-  # 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
-
-  # 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%5B%5D=Rails&hobbies%5B%5D=coding"
-  def to_query(key)
-    prefix = "#{key}[]"
-    collect { |value| value.to_query(prefix) }.join '&'
-  end
-
   # Converts a collection of elements into a formatted string by calling
   # <tt>to_s</tt> on all elements and joining them:
   #
@@ -156,34 +134,31 @@ class Array
   #   </messages>
   #
   def to_xml(options = {})
-    raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
-    require 'builder' unless defined?(Builder)
+    require 'active_support/builder' unless defined?(Builder)
 
     options = options.dup
-    options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(first.class.name)) : "records"
-    options[:children] ||= options[:root].singularize
-    options[:indent]   ||= 2
-    options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
-
-    root     = options.delete(:root).to_s
-    children = options.delete(:children)
-
-    if !options.has_key?(:dasherize) || options[:dasherize]
-      root = root.dasherize
+    options[:indent]  ||= 2
+    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    options[:root]    ||= if first.class.to_s != "Hash" && all? { |e| e.is_a?(first.class) }
+      underscored = ActiveSupport::Inflector.underscore(first.class.name)
+      ActiveSupport::Inflector.pluralize(underscored).tr('/', '_')
+    else
+      "objects"
     end
 
-    options[:builder].instruct! unless options.delete(:skip_instruct)
+    builder = options[:builder]
+    builder.instruct! unless options.delete(:skip_instruct)
 
-    opts = options.merge({ :root => children })
+    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
+    children = options.delete(:children) || root.singularize
 
-    xml = options[:builder]
-    if empty?
-      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
-    else
-      xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
-        yield xml if block_given?
-        each { |e| e.to_xml(opts.merge({ :skip_instruct => true })) }
-      }
+    attributes = options[:skip_types] ? {} : {:type => "array"}
+    return builder.tag!(root, attributes) if empty?
+
+    builder.__send__(:method_missing, root, attributes) do
+      each { |value| ActiveSupport::XmlMini.to_tag(children, value, options) }
+      yield builder if block_given?
     end
   end
+
 end