activesupport 3.0.pre → 3.0.0.rc

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

@@ -0,0 +1,50 @@
+require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/module/reachable'
+
+class Class #:nodoc:
+  # Rubinius
+  if defined?(Class.__subclasses__)
+    alias :subclasses :__subclasses__
+
+    def descendants
+      descendants = []
+      __subclasses__.each do |k|
+        descendants << k
+        descendants.concat k.descendants
+      end
+      descendants
+    end
+  else # MRI
+    begin
+      ObjectSpace.each_object(Class.new) {}
+
+      def descendants
+        descendants = []
+        ObjectSpace.each_object(class << self; self; end) do |k|
+          descendants.unshift k unless k == self
+        end
+        descendants
+      end
+    rescue StandardError # JRuby
+      def descendants
+        descendants = []
+        ObjectSpace.each_object(Class) do |k|
+          descendants.unshift k if k < self
+        end
+        descendants.uniq!
+        descendants
+      end
+    end
+
+    # Returns an array with the direct children of +self+.
+    #
+    #   Integer.subclasses # => [Bignum, Fixnum]
+    def subclasses
+      subclasses, chain = [], descendants
+      chain.each do |k|
+        subclasses << k unless chain.any? { |c| c > k }
+      end
+      subclasses
+    end
+  end
+end

data/lib/active_support/core_ext/date/calculations.rb

@@ -1,15 +1,37 @@
+require 'date'
 require 'active_support/duration'
+require 'active_support/core_ext/object/acts_like'
+require 'active_support/core_ext/date/zones'
+require 'active_support/core_ext/time/zones'
 
 class Date
+  if RUBY_VERSION < '1.9'
+    undef :>>
+    
+    # Backported from 1.9. The one in 1.8 leads to incorrect next_month and
+    # friends for dates where the calendar reform is involved. It additionally
+    # prevents an infinite loop fixed in r27013.
+    def >>(n)
+      y, m = (year * 12 + (mon - 1) + n).divmod(12)
+      m,   = (m + 1)                    .divmod(1)
+      d = mday
+      until jd2 = self.class.valid_civil?(y, m, d, start)
+        d -= 1
+        raise ArgumentError, 'invalid date' unless d > 0
+      end
+      self + (jd2 - jd)
+    end
+  end
+
   class << self
     # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
     def yesterday
-      ::Date.today.yesterday
+      ::Date.current.yesterday
     end
 
     # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
     def tomorrow
-      ::Date.today.tomorrow
+      ::Date.current.tomorrow
     end
 
     # Returns Time.zone.today when config.time_zone is set, otherwise just returns Date.today.
@@ -36,19 +58,19 @@ class Date
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
   # and then subtracts the specified number of seconds
   def ago(seconds)
-    to_time.since(-seconds)
+    to_time_in_current_zone.since(-seconds)
   end
 
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
   # and then adds the specified number of seconds
   def since(seconds)
-    to_time.since(seconds)
+    to_time_in_current_zone.since(seconds)
   end
   alias :in :since
 
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
   def beginning_of_day
-    to_time
+    to_time_in_current_zone
   end
   alias :midnight :beginning_of_day
   alias :at_midnight :beginning_of_day
@@ -56,7 +78,7 @@ class Date
 
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the end of the day (23:59:59)
   def end_of_day
-    to_time.end_of_day
+    to_time_in_current_zone.end_of_day
   end
 
   def plus_with_duration(other) #:nodoc:
@@ -125,20 +147,20 @@ class Date
     advance(:years => years)
   end
 
-  # Short-hand for years_ago(1)
-  def last_year
+  # Shorthand for years_ago(1)
+  def prev_year
     years_ago(1)
-  end
+  end unless method_defined?(:prev_year)
 
   # Short-hand for years_since(1)
   def next_year
     years_since(1)
   end unless method_defined?(:next_year)
-
+  
   # Short-hand for months_ago(1)
-  def last_month
+  def prev_month
     months_ago(1)
-  end
+  end unless method_defined?(:prev_month)
 
   # Short-hand for months_since(1)
   def next_month
@@ -160,6 +182,7 @@ class Date
     result = self + days_to_sunday.days
     self.acts_like?(:time) ? result.end_of_day : result
   end
+  alias :sunday :end_of_week
   alias :at_end_of_week :end_of_week
 
   # Returns a new Date/DateTime representing the start of the given day in next week (default is Monday).

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

@@ -1,6 +1,6 @@
+require 'date'
 require 'active_support/inflector'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/date/zones'
 
 class Date
   DATE_FORMATS = {
@@ -13,10 +13,10 @@ class Date
   }
 
   # Ruby 1.9 has Date#to_time which converts to localtime only.
-  remove_method :to_time if instance_methods.include?(:to_time)
+  remove_method :to_time if method_defined?(:to_time)
 
   # Ruby 1.9 has Date#xmlschema which converts to a string without the time component.
-  remove_method :xmlschema if instance_methods.include?(:xmlschema)
+  remove_method :xmlschema if method_defined?(:xmlschema)
 
   # Convert to a formatted string. See DATE_FORMATS for predefined formats.
   #
@@ -94,6 +94,6 @@ class Date
   end if RUBY_VERSION < '1.9'
 
   def xmlschema
-    to_time.xmlschema
+    to_time_in_current_zone.xmlschema
   end
 end

data/lib/active_support/core_ext/date/zones.rb

@@ -0,0 +1,14 @@
+require 'date'
+require 'active_support/core_ext/time/zones'
+
+class Date
+  # Converts Date to a TimeWithZone in the current zone if Time.zone_default is set,
+  # otherwise converts Date to a Time via Date#to_time
+  def to_time_in_current_zone
+    if ::Time.zone_default
+      ::Time.zone.local(year, month, day)
+    else
+      to_time
+    end
+  end
+end

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

@@ -1,4 +1,6 @@
-require 'rational'
+require 'rational' unless RUBY_VERSION >= '1.9.2'
+require 'active_support/core_ext/object/acts_like'
+require 'active_support/core_ext/time/zones'
 
 class DateTime
   class << self

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

@@ -1,4 +1,7 @@
 require 'active_support/inflector'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/date_time/calculations'
+require 'active_support/values/time_zone'
 
 class DateTime
   # Ruby 1.9 has DateTime#to_time which internally relies on Time. We define our own #to_time which allows
@@ -58,7 +61,7 @@ class DateTime
   # Converts self to a Ruby Date object; time portion is discarded
   def to_date
     ::Date.new(year, month, day)
-  end unless method_defined?(:to_date)
+  end unless instance_methods(false).include?(:to_date)
 
   # Attempts to convert self to a Ruby Time object; returns self if out of range of Ruby Time class
   # If self has an offset other than 0, self will just be returned unaltered, since there's no clean way to map it to a Time
@@ -69,16 +72,32 @@ class DateTime
   # To be able to keep Times, Dates and DateTimes interchangeable on conversions
   def to_datetime
     self
-  end unless method_defined?(:to_datetime)
+  end unless instance_methods(false).include?(:to_datetime)
+
+  def self.civil_from_format(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0)
+    offset = utc_or_local.to_sym == :local ? local_offset : 0
+    civil(year, month, day, hour, min, sec, offset)
+  end
 
   # Converts datetime to an appropriate format for use in XML
   def xmlschema
     strftime("%Y-%m-%dT%H:%M:%S%Z")
-  end unless method_defined?(:xmlschema)
+  end unless instance_methods(false).include?(:xmlschema)
   
   # Converts self to a floating-point number of seconds since the Unix epoch 
   def to_f
-    days_since_unix_epoch = self - ::DateTime.civil(1970)
-    (days_since_unix_epoch * 86_400).to_f
+    seconds_since_unix_epoch.to_f
+  end
+
+  # Converts self to an integer number of seconds since the Unix epoch
+  def to_i
+    seconds_since_unix_epoch.to_i
+  end
+
+  private
+
+  def seconds_since_unix_epoch
+    seconds_per_day = 86_400
+    (self - ::DateTime.civil(1970)) * seconds_per_day
   end
 end

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

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/time/zones'
+
 class DateTime
   # Returns the simultaneous time in <tt>Time.zone</tt>.
   #
@@ -12,6 +14,8 @@ class DateTime
   #
   #   DateTime.new(2000).in_time_zone('Alaska')  # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
   def in_time_zone(zone = ::Time.zone)
+    return self unless zone
+
     ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.__send__(:get_zone, zone))
   end
 end

data/lib/active_support/core_ext/enumerable.rb

@@ -101,15 +101,11 @@ module Enumerable
     size = block_given? ? select(&block).size : self.size
     size > 1
   end
-
-  # Returns true if none of the elements match the given block.
-  #
-  #   success = responses.none? {|r| r.status / 100 == 5 }
-  #
-  # This is a builtin method in Ruby 1.8.7 and later.
-  def none?(&block)
-    !any?(&block)
-  end unless [].respond_to?(:none?)
+  
+  # The negative of the Enumerable#include?. Returns true if the collection does not include the object.
+  def exclude?(object)
+    !include?(object)
+  end
 end
 
 class Range #:nodoc:

data/lib/active_support/core_ext/exception.rb

@@ -1,50 +1,3 @@
 module ActiveSupport
   FrozenObjectError = RUBY_VERSION < '1.9' ? TypeError : RuntimeError
 end
-
-# TODO: Turn all this into using the BacktraceCleaner.
-class Exception # :nodoc:
-  # Clean the paths contained in the message.
-  def self.clean_paths(string)
-    require 'pathname' unless defined? Pathname
-    string.gsub(%r{[\w. ]+(/[\w. ]+)+(\.rb)?(\b|$)}) do |path|
-      Pathname.new(path).cleanpath
-    end
-  end
-
-  def clean_message
-    Exception.clean_paths(message)
-  end
-
-  TraceSubstitutions = []
-  FrameworkStart = /action_controller\/dispatcher\.rb/.freeze
-  FrameworkRegexp = /generated|vendor|dispatch|ruby|script\/\w+/.freeze
-
-  def clean_backtrace
-    backtrace.collect do |line|
-      substituted = TraceSubstitutions.inject(line) do |result, (regexp, sub)|
-        result.gsub regexp, sub
-      end
-      Exception.clean_paths(substituted)
-    end
-  end
-
-  def application_backtrace
-    before_framework_frame = nil
-    before_application_frame = true
-
-    trace = clean_backtrace.reject do |line|
-      before_framework_frame ||= (line =~ FrameworkStart)
-      non_app_frame = (line =~ FrameworkRegexp)
-      before_application_frame = false unless non_app_frame
-      before_framework_frame || (non_app_frame && !before_application_frame)
-    end
-
-    # If we didn't find any application frames, return an empty app trace.
-    before_application_frame ? [] : trace
-  end
-
-  def framework_backtrace
-    clean_backtrace.grep FrameworkRegexp
-  end
-end

data/lib/active_support/core_ext/file.rb

@@ -1 +1,2 @@
 require 'active_support/core_ext/file/atomic'
+require 'active_support/core_ext/file/path'

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/float/rounding.rb

@@ -1,5 +1,6 @@
 class Float
-  remove_method :round
+  alias precisionless_round round
+  private :precisionless_round
 
   # Rounds the float with the specified precision.
   #
@@ -12,7 +13,7 @@ class Float
       magnitude = 10.0 ** precision
       (self * magnitude).round / magnitude
     else
-      super()
+      precisionless_round
     end
   end
 end

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

@@ -1,148 +1,76 @@
+require 'active_support/xml_mini'
 require 'active_support/time'
-require 'active_support/core_ext/object/conversions'
-require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
 
 class Hash
-  # This module exists to decorate files deserialized using Hash.from_xml with
-  # the <tt>original_filename</tt> and <tt>content_type</tt> methods.
-  module FileLike #:nodoc:
-    attr_writer :original_filename, :content_type
-
-    def original_filename
-      @original_filename || 'untitled'
-    end
-
-    def content_type
-      @content_type || 'application/octet-stream'
-    end
-  end
-
-  XML_TYPE_NAMES = {
-    "Symbol"     => "symbol",
-    "Fixnum"     => "integer",
-    "Bignum"     => "integer",
-    "BigDecimal" => "decimal",
-    "Float"      => "float",
-    "TrueClass"  => "boolean",
-    "FalseClass" => "boolean",
-    "Date"       => "date",
-    "DateTime"   => "datetime",
-    "Time"       => "datetime"
-  } unless defined?(XML_TYPE_NAMES)
-
-  XML_FORMATTING = {
-    "symbol"   => Proc.new { |symbol| symbol.to_s },
-    "date"     => Proc.new { |date| date.to_s(:db) },
-    "datetime" => Proc.new { |time| time.xmlschema },
-    "binary"   => Proc.new { |binary| ActiveSupport::Base64.encode64(binary) },
-    "yaml"     => Proc.new { |yaml| yaml.to_yaml }
-  } unless defined?(XML_FORMATTING)
-
-  # TODO: use Time.xmlschema instead of Time.parse;
-  #       use regexp instead of Date.parse
-  unless defined?(XML_PARSING)
-    XML_PARSING = {
-      "symbol"       => Proc.new  { |symbol|  symbol.to_sym },
-      "date"         => Proc.new  { |date|    ::Date.parse(date) },
-      "datetime"     => Proc.new  { |time|    ::Time.parse(time).utc rescue ::DateTime.parse(time).utc },
-      "integer"      => Proc.new  { |integer| integer.to_i },
-      "float"        => Proc.new  { |float|   float.to_f },
-      "decimal"      => Proc.new  { |number|  BigDecimal(number) },
-      "boolean"      => Proc.new  { |boolean| %w(1 true).include?(boolean.strip) },
-      "string"       => Proc.new  { |string|  string.to_s },
-      "yaml"         => Proc.new  { |yaml|    YAML::load(yaml) rescue yaml },
-      "base64Binary" => Proc.new  { |bin|     ActiveSupport::Base64.decode64(bin) },
-      "file"         => Proc.new do |file, entity|
-        f = StringIO.new(ActiveSupport::Base64.decode64(file))
-        f.extend(FileLike)
-        f.original_filename = entity['name']
-        f.content_type = entity['content_type']
-        f
-      end
-    }
-
-    XML_PARSING.update(
-      "double"   => XML_PARSING["float"],
-      "dateTime" => XML_PARSING["datetime"]
-    )
-  end
-
-  # 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).
+  # Returns a string containing an XML representation of its receiver:
+  # 
+  #   {"foo" => 1, "bar" => 2}.to_xml
+  #   # =>
+  #   # <?xml version="1.0" encoding="UTF-8"?>
+  #   # <hash>
+  #   #   <foo type="integer">1</foo>
+  #   #   <bar type="integer">2</bar>
+  #   # </hash>
+  # 
+  # To do so, the method loops over the pairs and builds nodes that depend on
+  # the _values_. Given a pair +key+, +value+:
+  # 
+  # * If +value+ is a hash there's a recursive call with +key+ as <tt>:root</tt>.
+  # 
+  # * If +value+ is an array there's a recursive call with +key+ as <tt>:root</tt>,
+  #   and +key+ singularized as <tt>:children</tt>.
+  # 
+  # * If +value+ is a callable object it must expect one or two arguments. Depending
+  #   on the arity, the callable is invoked with the +options+ hash as first argument
+  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. Its
+  #   return value becomes a new node.
+  # 
+  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
+  # 
+  # * Otherwise, a node with +key+ as tag is created with a string representation of
+  #   +value+ as text node. If +value+ is +nil+ an attribute "nil" set to "true" is added.
+  #   Unless the option <tt>:skip_types</tt> exists and is true, an attribute "type" is
+  #   added as well according to the following mapping:
   #
-  # ==== Examples
-  #   { :name => 'David', :nationality => 'Danish' }.to_query # => "name=David&nationality=Danish"
-  #
-  #   { :name => 'David', :nationality => 'Danish' }.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
-  def to_query(namespace = nil)
-    collect do |key, value|
-      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-    end.sort * '&'
-  end
-  
-  alias_method :to_param, :to_query
-
+  #     XML_TYPE_NAMES = {
+  #       "Symbol"     => "symbol",
+  #       "Fixnum"     => "integer",
+  #       "Bignum"     => "integer",
+  #       "BigDecimal" => "decimal",
+  #       "Float"      => "float",
+  #       "TrueClass"  => "boolean",
+  #       "FalseClass" => "boolean",
+  #       "Date"       => "date",
+  #       "DateTime"   => "datetime",
+  #       "Time"       => "datetime"
+  #     }
+  # 
+  # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
+  # 
+  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
+  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
+  # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
   def to_xml(options = {})
-    require 'builder' unless defined?(Builder)
+    require 'active_support/builder' unless defined?(Builder)
 
     options = options.dup
-    options[:indent] ||= 2
-    options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
-                             :root => "hash" })
-    options[:builder].instruct! unless options.delete(:skip_instruct)
-    root = rename_key(options[:root].to_s, options)
+    options[:indent]  ||= 2
+    options[:root]    ||= "hash"
+    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
 
-    options[:builder].__send__(:method_missing, root) do
-      each do |key, value|
-        case value
-          when ::Hash
-            value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
-          when ::Array
-            value.to_xml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
-          when ::Method, ::Proc
-            # If the Method or Proc takes two arguments, then
-            # pass the suggested child element name.  This is
-            # used if the Method or Proc will be operating over
-            # multiple records and needs to create an containing
-            # element that will contain the objects being
-            # serialized.
-            if 1 == value.arity
-              value.call(options.merge({ :root => key, :skip_instruct => true }))
-            else
-              value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
-            end
-          else
-            if value.respond_to?(:to_xml)
-              value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
-            else
-              type_name = XML_TYPE_NAMES[value.class.name]
+    builder = options[:builder]
+    builder.instruct! unless options.delete(:skip_instruct)
 
-              key = rename_key(key.to_s, options)
+    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
 
-              attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
-              if value.nil?
-                attributes[:nil] = true
-              end
-
-              options[:builder].tag!(key,
-                XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
-                attributes
-              )
-            end
-        end
-      end
-      
-      yield options[:builder] if block_given?
+    builder.__send__(:method_missing, root) do
+      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
+      yield builder if block_given?
     end
-
-  end
-
-  def rename_key(key, options = {})
-    camelize = options.has_key?(:camelize) && options[:camelize]
-    dasherize = !options.has_key?(:dasherize) || options[:dasherize]
-    key = key.camelize if camelize
-    dasherize ? key.dasherize : key
   end
 
   class << self
@@ -155,7 +83,7 @@ class Hash
         case value.class.to_s
           when 'Hash'
             if value['type'] == 'array'
-              child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
+              _, entries = Array.wrap(value.detect { |k,v| k != 'type' })
               if entries.nil? || (c = value['__content__'] && c.blank?)
                 []
               else
@@ -170,12 +98,8 @@ class Hash
               end
             elsif value.has_key?("__content__")
               content = value["__content__"]
-              if parser = XML_PARSING[value["type"]]
-                if parser.arity == 2
-                  XML_PARSING[value["type"]].call(content, value)
-                else
-                  XML_PARSING[value["type"]].call(content)
-                end
+              if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
+                parser.arity == 1 ? parser.call(content) : parser.call(content, value)
               else
                 content
               end
@@ -201,11 +125,7 @@ class Hash
             end
           when 'Array'
             value.map! { |i| typecast_xml_value(i) }
-            case value.length
-              when 0 then nil
-              when 1 then value.first
-              else value
-            end
+            value.length > 1 ? value : value.first
           when 'String'
             value
           else