activesupport 3.0.0.beta4 → 3.0.pre

data/lib/active_support/callbacks.rb

@@ -1,7 +1,6 @@
 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
@@ -91,7 +90,7 @@ module ActiveSupport
     class Callback
       @@_callback_sequence = 0
 
-      attr_accessor :chain, :filter, :kind, :options, :per_key, :klass, :raw_filter
+      attr_accessor :chain, :filter, :kind, :options, :per_key, :klass
 
       def initialize(chain, filter, kind, options, klass)
         @chain, @kind, @klass = chain, kind, klass
@@ -203,8 +202,8 @@ module ActiveSupport
             # end
             #
             name = "_conditional_callback_#{@kind}_#{next_id}"
-            @klass.class_eval <<-RUBY_EVAL,  __FILE__, __LINE__ + 1
-               def #{name}(halted)
+            txt, line = <<-RUBY_EVAL, __LINE__ + 1
+              def #{name}(halted)
                 #{@compiled_options[0] || "if true"} && !halted
                   #{@filter} do
                     yield self
@@ -214,6 +213,7 @@ module ActiveSupport
                 end
               end
             RUBY_EVAL
+            @klass.class_eval(txt, __FILE__, line)
             "#{name}(halted) do"
           end
         end
@@ -311,9 +311,9 @@ module ActiveSupport
 
       def _normalize_legacy_filter(kind, filter)
         if !filter.respond_to?(kind) && filter.respond_to?(:filter)
-          filter.singleton_class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-            def #{kind}(context, &block) filter(context, &block) end
-          RUBY_EVAL
+          filter.metaclass.class_eval(
+            "def #{kind}(context, &block) filter(context, &block) end",
+            __FILE__, __LINE__ - 1)
         elsif filter.respond_to?(:before) && filter.respond_to?(:after) && kind == :around
           def filter.around(context)
             should_continue = before(context)
@@ -367,6 +367,12 @@ 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
@@ -383,35 +389,28 @@ module ActiveSupport
       # key. See #define_callbacks for more information.
       #
       def __define_runner(symbol) #:nodoc:
-        send("_update_#{symbol}_superclass_callbacks")
         body = send("_#{symbol}_callbacks").compile(nil)
 
-        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)
-              @_initialized_#{symbol}_callbacks ||= begin
-                if self.class.send("_update_#{symbol}_superclass_callbacks")
-                  self.class.__define_runner(#{symbol.inspect})
-                  return _run_#{symbol}_callbacks(key, &blk)
-                end
-                true
-              end
-
-              if key
-                name = "_run__\#{self.class.name.hash.abs}__#{symbol}__\#{key.hash.abs}__callbacks"
+        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"
 
-                unless respond_to?(name)
-                  self.class.__create_keyed_callback(name, :#{symbol}, self, &blk)
-                end
-
-                send(name, &blk)
-              else
-                #{body}
+              unless respond_to?(name)
+                self.class.__create_keyed_callback(name, :#{symbol}, self, &blk)
               end
+
+              send(name, &blk)
+            else
+              #{body}
             end
-            private :_run_#{symbol}_callbacks
-          RUBY_EVAL
+          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
         end
       end
 
@@ -432,8 +431,6 @@ module ActiveSupport
       # CallbackChain.
       #
       def __update_callbacks(name, filters = [], block = nil) #:nodoc:
-        send("_update_#{name}_superclass_callbacks")
-
         type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before
         options = filters.last.is_a?(Hash) ? filters.pop : {}
         filters.unshift(block) if block
@@ -470,11 +467,10 @@ module ActiveSupport
       # method that took into consideration the per_key conditions. This
       # is a speed improvement for ActionPack.
       #
-      def set_callback(name, *filter_list, &block)
-        __update_callbacks(name, filter_list, block) do |chain, type, filters, options|
+      def set_callback(name, *filters, &block)
+        __update_callbacks(name, filters, block) do |chain, type, filters, options|
           filters.map! do |filter|
-            removed = chain.delete_if {|c| c.matches?(type, filter) } 
-            send("_removed_#{name}_callbacks").push(*removed)
+            chain.delete_if {|c| c.matches?(type, filter) }
             Callback.new(chain, filter, type, options.dup, self)
           end
 
@@ -484,19 +480,18 @@ module ActiveSupport
 
       # Skip a previously defined callback for a given type.
       #
-      def skip_callback(name, *filter_list, &block)
-        __update_callbacks(name, filter_list, block) do |chain, type, filters, options|
+      def skip_callback(name, *filters, &block)
+        __update_callbacks(name, filters, block) do |chain, type, filters, options|
+          chain = send("_#{name}_callbacks=", chain.clone(self))
+
           filters.each do |filter|
             filter = chain.find {|c| c.matches?(type, filter) }
 
             if filter && options.any?
-              new_filter = filter.clone(chain, self)
-              chain.insert(chain.index(filter), new_filter)
-              new_filter.recompile!(options, options[:per_key] || {})
+              filter.recompile!(options, options[:per_key] || {})
+            else
+              chain.delete(filter)
             end
-
-            chain.delete(filter)
-            send("_removed_#{name}_callbacks") << filter
           end
         end
       end
@@ -504,9 +499,7 @@ module ActiveSupport
       # Reset callbacks for a given type.
       #
       def reset_callbacks(symbol)
-        callbacks = send("_#{symbol}_callbacks")
-        callbacks.clear
-        send("_removed_#{symbol}_callbacks").concat(callbacks)
+        send("_#{symbol}_callbacks").clear
         __define_runner(symbol)
       end
 
@@ -531,7 +524,7 @@ module ActiveSupport
       # to change this behavior.
       #
       # * <tt>:scope</tt> - Show which methods should be executed when a class
-      # is given as callback:
+      # is giben as callback:
       #
       #   define_callbacks :filters, :scope => [ :kind ]
       #
@@ -553,46 +546,14 @@ module ActiveSupport
       #
       # Defaults to :kind.
       #
-      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)
+      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)
           end
 
-          extlib_inheritable_reader("_removed_#{callback}_callbacks") do
-            []
-          end
-
-          class_eval <<-METHOD, __FILE__, __LINE__ + 1
-            def self._#{callback}_superclass_callbacks
-              if superclass.respond_to?(:_#{callback}_callbacks)
-                superclass._#{callback}_callbacks + superclass._#{callback}_superclass_callbacks
-              else
-                []
-              end
-            end
-
-            def self._update_#{callback}_superclass_callbacks
-              changed, index = false, 0
-
-              callbacks  = (_#{callback}_superclass_callbacks -
-                _#{callback}_callbacks) - _removed_#{callback}_callbacks
-
-              callbacks.each do |callback|
-                if new_index = _#{callback}_callbacks.index(callback)
-                  index = new_index + 1
-                else
-                  changed = true
-                  _#{callback}_callbacks.insert(index, callback)
-                  index = index + 1
-                end
-              end
-              changed
-            end
-          METHOD
-
-          __define_runner(callback)
+          __define_runner(symbol)
         end
       end
     end

data/lib/active_support/configurable.rb

@@ -1,36 +1,35 @@
-require 'active_support/concern'
-require 'active_support/ordered_options'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/delegation'
+require "active_support/concern"
 
 module ActiveSupport
   module Configurable
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def config
-        @config ||= ActiveSupport::InheritableOptions.new(superclass.respond_to?(:config) ? superclass.config : {})
+      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 configure
-        yield config
+      
+      def config
+        self.config = get_config unless @config
+        @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
+      def config=(hash)
+        @config = ActiveSupport::OrderedOptions.new
+        hash.each do |key, value|
+          @config[key] = value
         end
       end
     end
 
     def config
-      @config ||= ActiveSupport::InheritableOptions.new(self.class.config)
+      self.class.config
     end
   end
 end

data/lib/active_support/core_ext/array.rb

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

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

@@ -1,7 +1,6 @@
-require 'active_support/xml_mini'
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/string/inflections'
+require 'active_support/inflector'
 
 class Array
   # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
@@ -9,14 +8,21 @@ 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 = {})
-    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 "
+    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
     end
 
     options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
@@ -34,6 +40,22 @@ 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:
   #
@@ -134,31 +156,34 @@ class Array
   #   </messages>
   #
   def to_xml(options = {})
-    require 'active_support/builder' unless defined?(Builder)
+    raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+    require 'builder' unless defined?(Builder)
 
     options = options.dup
-    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[: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])
 
-    builder = options[:builder]
-    builder.instruct! unless options.delete(:skip_instruct)
+    root     = options.delete(:root).to_s
+    children = options.delete(:children)
 
-    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
-    children = options.delete(:children) || root.singularize
+    if !options.has_key?(:dasherize) || options[:dasherize]
+      root = root.dasherize
+    end
+
+    options[:builder].instruct! unless options.delete(:skip_instruct)
 
-    attributes = options[:skip_types] ? {} : {:type => "array"}
-    return builder.tag!(root, attributes) if empty?
+    opts = options.merge({ :root => children })
 
-    builder.__send__(:method_missing, root, attributes) do
-      each { |value| ActiveSupport::XmlMini.to_tag(children, value, options) }
-      yield builder if block_given?
+    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 })) }
+      }
     end
   end
-
 end

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

@@ -1,14 +1,3 @@
-class Hash
-  # By default, only instances of Hash itself are extractable.
-  # Subclasses of Hash may implement this method and return
-  # true to declare themselves as extractable. If a Hash
-  # is extractable, Array#extract_options! pops it from
-  # the Array when it is the last element of the Array.
-  def extractable_options?
-    instance_of?(Hash)
-  end
-end
-
 class Array
   # Extracts options from a set of arguments. Removes and returns the last
   # element in the array if it's a hash, otherwise returns a blank hash.
@@ -20,10 +9,6 @@ class Array
   #   options(1, 2)           # => {}
   #   options(1, 2, :a => :b) # => {:a=>:b}
   def extract_options!
-    if last.is_a?(Hash) && last.extractable_options?
-      pop
-    else
-      {}
-    end
+    last.is_a?(::Hash) ? pop : {}
   end
 end

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

@@ -1,20 +1,6 @@
 class Array
-  # Backport of Array#sample based on Marc-Andre Lafortune's http://github.com/marcandre/backports/
-  def sample(n=nil)
-    return self[Kernel.rand(size)] if n.nil?
-    n = n.to_int
-  rescue Exception => e
-    raise TypeError, "Coercion error: #{n.inspect}.to_int => Integer failed:\n(#{e.message})"
-  else
-    raise TypeError, "Coercion error: obj.to_int did NOT return an Integer (was #{n.class})" unless n.kind_of? Integer
-    raise ArgumentError, "negative array size" if n < 0
-    n = size if n > size
-    result = Array.new(self)
-    n.times do |i|
-      r = i + Kernel.rand(size - i)
-      result[i], result[r] = result[r], result[i]
-    end
-    result[n..size] = []
-    result
-  end unless method_defined? :sample
-end
+  # Returns a random element from the array.
+  def rand
+    self[Kernel.rand(length)]
+  end
+end