activesupport 3.0.0.beta → 3.0.0.beta2

data/CHANGELOG

@@ -1,4 +1,18 @@
-*Rails 3.0 (pending)*
+*Rails 3.0.0 [beta 2] (April 1st, 2010)*
+
+* Reduced load time by deferring configuration of classes using
+  ActiveSupport::on_load(:component_name) [YK]
+
+* Rename #metaclass to #singleton_class now that ruby-core has decided [JK]
+
+* New assertions assert_blank and assert_present.  #4299 [Juanjo Bazan] 
+
+* Use Object#singleton_class instead of #metaclass. Prefer Ruby's choice.  [Jeremy Kemper]
+
+* JSON backend for YAJL. Preferred if available.  #2666 [Brian Lopez]
+
+
+*Rails 3.0.0 [beta 1] (February 4, 2010)*
 
 * Introduce class_attribute to declare inheritable class attributes. Writing an attribute on a subclass behaves just like overriding the superclass reader method.  Unifies and replaces most usage of cattr_accessor, class_inheritable_attribute, superclass_delegating_attribute, and extlib_inheritable_attribute.  [Jeremy Kemper, Yehuda Katz]
 

data/lib/active_support.rb

@@ -53,6 +53,7 @@ module ActiveSupport
     autoload :Deprecation
     autoload :Gzip
     autoload :Inflector
+    autoload :JSON
     autoload :Memoizable
     autoload :MessageEncryptor
     autoload :MessageVerifier
@@ -70,3 +71,5 @@ module ActiveSupport
   autoload :SafeBuffer, "active_support/core_ext/string/output_safety"
   autoload :TestCase
 end
+
+autoload :I18n, "active_support/i18n"

data/lib/active_support/all.rb

@@ -1,4 +1,3 @@
 require 'active_support'
-require 'active_support/i18n'
 require 'active_support/time'
 require 'active_support/core_ext'

data/lib/active_support/cache/mem_cache_store.rb

@@ -91,7 +91,7 @@ module ActiveSupport
 
       def delete(key, options = nil) # :nodoc:
         super do
-          response = @data.delete(key, expires_in(options))
+          response = @data.delete(key)
           response == Response::DELETED
         end
       rescue MemCache::MemCacheError => e

data/lib/active_support/callbacks.rb

@@ -1,7 +1,7 @@
 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/object/metaclass'
+require 'active_support/core_ext/object/singleton_class'
 
 module ActiveSupport
   # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
@@ -312,7 +312,7 @@ module ActiveSupport
 
       def _normalize_legacy_filter(kind, filter)
         if !filter.respond_to?(kind) && filter.respond_to?(:filter)
-          filter.metaclass.class_eval(
+          filter.singleton_class.class_eval(
             "def #{kind}(context, &block) filter(context, &block) end",
             __FILE__, __LINE__ - 1)
         elsif filter.respond_to?(:before) && filter.respond_to?(:after) && kind == :around

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

@@ -1,7 +1,6 @@
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/inflector'
-require 'active_support/i18n'
 
 class Array
   # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:

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

@@ -1,3 +1,14 @@
+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.
@@ -9,6 +20,10 @@ class Array
   #   options(1, 2)           # => {}
   #   options(1, 2, :a => :b) # => {:a=>:b}
   def extract_options!
-    last.is_a?(::Hash) ? pop : {}
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
   end
 end

data/lib/active_support/core_ext/class.rb

@@ -1,3 +1,4 @@
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/class/inheritable_attributes'
 require 'active_support/core_ext/class/delegating_attributes'
+require 'active_support/core_ext/class/subclasses'

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

@@ -1,5 +1,6 @@
-require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/singleton_class'
 require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/remove_method'
 
 class Class
   # Declare a class-level attribute whose value is inheritable and
@@ -24,13 +25,37 @@ class Class
   # For convenience, a query method is defined as well:
   #
   #   Subclass.setting?           # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance writer method, pass :instance_writer => false.
+  #
+  #   object.setting = false  # => NoMethodError
   def class_attribute(*attrs)
+    instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]
+
+    s = singleton_class
     attrs.each do |attr|
-      metaclass.send(:define_method, attr) { }
-      metaclass.send(:define_method, "#{attr}?") { !!send(attr) }
-      metaclass.send(:define_method, "#{attr}=") do |value|
-        metaclass.send(:define_method, attr) { value }
+      s.send(:define_method, attr) { }
+      s.send(:define_method, :"#{attr}?") { !!send(attr) }
+      s.send(:define_method, :"#{attr}=") do |value|
+        singleton_class.remove_possible_method(attr)
+        singleton_class.send(:define_method, attr) { value }
       end
+
+      define_method(attr) { self.class.send(attr) }
+      define_method(:"#{attr}?") { !!send(attr) }
+      define_method(:"#{attr}=") do |value|
+        singleton_class.remove_possible_method(attr)
+        singleton_class.send(:define_method, attr) { value }
+      end if instance_writer
     end
   end
 end

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

@@ -10,42 +10,48 @@ require 'active_support/core_ext/array/extract_options'
 #  Person.hair_colors = [:brown, :black, :blonde, :red]
 class Class
   def cattr_reader(*syms)
-    syms.flatten.each do |sym|
-      next if sym.is_a?(Hash)
+    options = syms.extract_options!
+    syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}  # unless defined? @@hair_colors
-          @@#{sym} = nil          #   @@hair_colors = nil
-        end                       # end
-                                  #
-        def self.#{sym}           # def self.hair_colors
-          @@#{sym}                #   @@hair_colors
-        end                       # end
-                                  #
-        def #{sym}                # def hair_colors
-          @@#{sym}                #   @@hair_colors
-        end                       # end
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
       EOS
+
+      unless options[:instance_reader] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+      end
     end
   end
 
   def cattr_writer(*syms)
     options = syms.extract_options!
-    syms.flatten.each do |sym|
+    syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}                       # unless defined? @@hair_colors
-          @@#{sym} = nil                               #   @@hair_colors = nil
-        end                                            # end
-                                                       #
-        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
-          @@#{sym} = obj                               #   @@hair_colors = obj
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def hair_colors=(obj)
-          @@#{sym} = obj                               #   @@hair_colors = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
       EOS
+
+      unless options[:instance_writer] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        EOS
+      end
       self.send("#{sym}=", yield) if block_given?
     end
   end

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

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/singleton_class'
+require 'active_support/core_ext/module/remove_method'
 
 class Class
   def superclass_delegating_accessor(name, options = {})
@@ -11,9 +12,9 @@ class Class
     # Generate the public methods name, name=, and name?
     # These methods dispatch to the private _name, and _name= methods, making them
     # overridable
-    metaclass.send(:define_method, name) { send("_#{name}") }
-    metaclass.send(:define_method, "#{name}?") { !!send("_#{name}") }
-    metaclass.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }
+    singleton_class.send(:define_method, name) { send("_#{name}") }
+    singleton_class.send(:define_method, "#{name}?") { !!send("_#{name}") }
+    singleton_class.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }
 
     # If an instance_reader is needed, generate methods for name and name= on the
     # class itself, so instances will be able to see them
@@ -27,15 +28,17 @@ private
   # inheritance behavior, without having to store the object in an instance
   # variable and look up the superclass chain manually.
   def _stash_object_in_method(object, method, instance_reader = true)
-    metaclass.send(:define_method, method) { object }
+    singleton_class.remove_possible_method(method)
+    singleton_class.send(:define_method, method) { object }
+    remove_possible_method(method)
     define_method(method) { object } if instance_reader
   end
 
   def _superclass_delegating_accessor(name, options = {})
-    metaclass.send(:define_method, "#{name}=") do |value|
+    singleton_class.send(:define_method, "#{name}=") do |value|
       _stash_object_in_method(value, name, options[:instance_reader] != false)
     end
-    self.send("#{name}=", nil)
+    send("#{name}=", nil)
   end
 
 end

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

@@ -0,0 +1,55 @@
+require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/module/reachable'
+
+class Class #:nodoc:
+  # Returns an array with the names of the subclasses of +self+ as strings.
+  #
+  #   Integer.subclasses # => ["Bignum", "Fixnum"]
+  def subclasses
+    Class.subclasses_of(self).map { |o| o.to_s }
+  end
+
+  # Rubinius
+  if defined?(Class.__subclasses__)
+    def descendents
+      subclasses = []
+      __subclasses__.each {|k| subclasses << k; subclasses.concat k.descendents }
+      subclasses
+    end
+  else
+    # MRI
+    begin
+      ObjectSpace.each_object(Class.new) {}
+
+      def descendents
+        subclasses = []
+        ObjectSpace.each_object(class << self; self; end) do |k|
+          subclasses << k unless k == self
+        end
+        subclasses
+      end
+    # JRuby
+    rescue StandardError
+      def descendents
+        subclasses = []
+        ObjectSpace.each_object(Class) do |k|
+          subclasses << k if k < self
+        end
+        subclasses.uniq!
+        subclasses
+      end
+    end
+  end
+
+  # Exclude this class unless it's a subclass of our supers and is defined.
+  # We check defined? in case we find a removed class that has yet to be
+  # garbage collected. This also fails for anonymous classes -- please
+  # submit a patch if you have a workaround.
+  def self.subclasses_of(*superclasses) #:nodoc:
+    subclasses = []
+    superclasses.each do |klass|
+      subclasses.concat klass.descendents.select {|k| k.anonymous? || k.reachable?}
+    end
+    subclasses
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'active_support/inflector'
+require 'active_support/core_ext/time/conversions'
 
 class DateTime
   # Ruby 1.9 has DateTime#to_time which internally relies on Time. We define our own #to_time which allows

data/lib/active_support/core_ext/file/atomic.rb

@@ -9,11 +9,12 @@ class File
   # If your temp directory is not on the same filesystem as the file you're
   # trying to write, you can provide a different temporary directory.
   #
-  #   File.atomic_write("/data/something.important", "/data/tmp") do |f|
+  #   File.atomic_write("/data/something.important", "/data/tmp") do |file|
   #     file.write("hello")
   #   end
   def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
     require 'tempfile' unless defined?(Tempfile)
+    require 'fileutils' unless defined?(FileUtils)
 
     temp_file = Tempfile.new(basename(file_name), temp_dir)
     yield temp_file
@@ -31,7 +32,7 @@ class File
     end
 
     # Overwrite original file with temp file
-    rename(temp_file.path, file_name)
+    FileUtils.mv(temp_file.path, file_name)
 
     # Set correct permissions on new file
     chown(old_stat.uid, old_stat.gid, file_name)

data/lib/active_support/core_ext/file/path.rb

@@ -0,0 +1,5 @@
+class File
+  unless File.allocate.respond_to?(:to_path)
+    alias to_path path
+  end
+end

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

@@ -54,6 +54,15 @@ class Hash
       "string"       => Proc.new  { |string|  string.to_s },
       "yaml"         => Proc.new  { |yaml|    YAML::load(yaml) rescue yaml },
       "base64Binary" => Proc.new  { |bin|     ActiveSupport::Base64.decode64(bin) },
+      "binary"       => Proc.new do |bin, entity|
+        case entity['encoding']
+	  when 'base64'
+	    ActiveSupport::Base64.decode64(bin)
+	  # TODO: Add support for other encodings
+	  else
+	    bin
+	end
+      end,
       "file"         => Proc.new do |file, entity|
         f = StringIO.new(ActiveSupport::Base64.decode64(file))
         f.extend(FileLike)

data/lib/active_support/core_ext/kernel.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/kernel/daemonizing'
 require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/agnostics'
 require 'active_support/core_ext/kernel/requires'

data/lib/active_support/core_ext/kernel/debugger.rb

@@ -1,6 +1,6 @@
 module Kernel
   unless respond_to?(:debugger)
-    # Starts a debugging session if ruby-debug has been loaded (call script/server --debugger to do load it).
+    # Starts a debugging session if ruby-debug has been loaded (call rails server --debugger to do load it).
     def debugger
       message = "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
       defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)

data/lib/active_support/core_ext/kernel/reporting.rb

@@ -37,7 +37,7 @@ module Kernel
   #   puts 'But this will'
   def silence_stream(stream)
     old_stream = stream.dup
-    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.reopen(RUBY_PLATFORM =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
     stream.sync = true
     yield
   ensure

data/lib/active_support/core_ext/module.rb

@@ -1,10 +1,12 @@
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/introspection'
-
-require 'active_support/core_ext/module/inclusion'
+require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/module/reachable'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/attr_internal'
 require 'active_support/core_ext/module/attr_accessor_with_default'
 require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/module/loading'
 require 'active_support/core_ext/module/synchronization'
+require 'active_support/core_ext/module/deprecation'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/module/method_names'

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

@@ -0,0 +1,24 @@
+require 'active_support/core_ext/object/blank'
+
+class Module
+  # A module may or may not have a name.
+  #
+  #   module M; end
+  #   M.name # => "M"
+  #
+  #   m = Module.new
+  #   m.name # => ""
+  #
+  # A module gets a name when it is first assigned to a constant. Either
+  # via the +module+ or +class+ keyword or by an explicit assignment:
+  #
+  #   m = Module.new # creates an anonymous module
+  #   M = m          # => m gets a name here as a side-effect
+  #   m.name         # => "M"
+  #
+  def anonymous?
+    # Uses blank? because the name of an anonymous class is an empty
+    # string in 1.8, and nil in 1.9.
+    name.blank? 
+  end
+end