activesupport 2.0.5 → 2.1.0

data/lib/active_support/core_ext/date_time.rb

@@ -1,10 +1,12 @@
 require 'date'
 require 'active_support/core_ext/time/behavior'
+require 'active_support/core_ext/time/zones'
 require 'active_support/core_ext/date_time/calculations'
 require 'active_support/core_ext/date_time/conversions'
 
 class DateTime
   include ActiveSupport::CoreExtensions::Time::Behavior
+  include ActiveSupport::CoreExtensions::Time::Zones
   include ActiveSupport::CoreExtensions::DateTime::Calculations
   include ActiveSupport::CoreExtensions::DateTime::Conversions
 end

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

@@ -7,6 +7,11 @@ module ActiveSupport #:nodoc:
       module Calculations
         def self.included(base) #:nodoc:
           base.extend ClassMethods
+          
+          base.class_eval do
+            alias_method :compare_without_coercion, :<=>
+            alias_method :<=>, :compare_with_coercion
+          end
         end
 
         module ClassMethods
@@ -37,8 +42,10 @@ module ActiveSupport #:nodoc:
           )
         end
 
-        # Uses Date to provide precise Time calculations for years, months, and days.  The +options+ parameter takes a hash with
-        # any of these keys: :years, :months, :weeks, :days, :hours, :minutes, :seconds.
+        # Uses Date to provide precise Time calculations for years, months, and days.
+        # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
+        # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
+        # <tt>:minutes</tt>, <tt>:seconds</tt>.
         def advance(options)
           d = to_date.advance(options)
           datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
@@ -71,6 +78,34 @@ module ActiveSupport #:nodoc:
         def end_of_day
           change(:hour => 23, :min => 59, :sec => 59)
         end
+        
+        # Adjusts DateTime to UTC by adding its offset value; offset is set to 0
+        #
+        # Example:
+        #
+        #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))       # => Mon, 21 Feb 2005 10:11:12 -0600
+        #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc   # => Mon, 21 Feb 2005 16:11:12 +0000
+        def utc
+          new_offset(0)
+        end
+        alias_method :getutc, :utc
+        
+        # Returns true if offset == 0
+        def utc?
+          offset == 0
+        end
+        
+        # Returns the offset value in seconds
+        def utc_offset
+          (offset * 86400).to_i
+        end
+        
+        # Layers additional behavior on DateTime#<=> so that Time and ActiveSupport::TimeWithZone instances can be compared with a DateTime
+        def compare_with_coercion(other)
+          other = other.comparable_time if other.respond_to?(:comparable_time)
+          other = other.to_datetime unless other.acts_like?(:date)
+          compare_without_coercion(other)
+        end
       end
     end
   end

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

@@ -3,16 +3,21 @@ module ActiveSupport #:nodoc:
     module DateTime #:nodoc:
       # Converting datetimes to formatted strings, dates, and times.
       module Conversions
-        def self.included(base) #:nodoc:
+        def self.append_features(base) #:nodoc:
           base.class_eval do
-            alias_method :to_datetime_default_s, :to_s
-            alias_method :to_s, :to_formatted_s
             alias_method :default_inspect, :inspect
-            alias_method :inspect, :readable_inspect
+            alias_method :to_default_s, :to_s unless (instance_methods(false) & [:to_s, 'to_s']).empty?
 
             # Ruby 1.9 has DateTime#to_time which internally relies on Time. We define our own #to_time which allows
             # DateTimes outside the range of what can be created with Time.
-            remove_method :to_time if base.instance_methods.include?(:to_time)
+            remove_method :to_time if instance_methods.include?(:to_time)
+          end
+
+          super
+
+          base.class_eval do
+            alias_method :to_s, :to_formatted_s
+            alias_method :inspect, :readable_inspect
           end
         end
 
@@ -41,17 +46,19 @@ module ActiveSupport #:nodoc:
         #   Time::DATE_FORMATS[:month_and_year] = "%B %Y"
         #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
         def to_formatted_s(format = :default)
-          if formatter = ::Time::DATE_FORMATS[format]
-            if formatter.respond_to?(:call)
-              formatter.call(self).to_s
-            else
-              strftime(formatter)
-            end
-          else
-            to_datetime_default_s
-          end
+          return to_default_s unless formatter = ::Time::DATE_FORMATS[format]
+          formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
         end
 
+        # Returns the +utc_offset+ as an +HH:MM formatted string. Examples:
+        #
+        #   datetime = DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-6, 24))
+        #   datetime.formatted_offset         # => "-06:00"
+        #   datetime.formatted_offset(false)  # => "-0600"
+        def formatted_offset(colon = true, alternate_utc_string = nil)
+          utc? && alternate_utc_string || utc_offset.to_utc_offset_s(colon)
+        end
+        
         # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005 14:30:00 +0000"
         def readable_inspect
           to_s(:rfc822)
@@ -77,6 +84,12 @@ module ActiveSupport #:nodoc:
         def xmlschema
           strftime("%Y-%m-%dT%H:%M:%S%Z")
         end if RUBY_VERSION < '1.9'
+        
+        # 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
+        end
       end
     end
   end

data/lib/active_support/core_ext/enumerable.rb

@@ -1,11 +1,14 @@
 module Enumerable
+  # Ruby 1.8.7 introduces group_by, but the result isn't ordered. Override it.
+  remove_method(:group_by) if [].respond_to?(:group_by) && RUBY_VERSION < '1.9'
+
   # Collect an enumerable into sets, grouped by the result of a block. Useful,
   # for example, for grouping records by date.
   #
-  # e.g. 
+  # Example:
   #
   #   latest_transcripts.group_by(&:day).each do |day, transcripts| 
-  #     p "#{day} -> #{transcripts.map(&:class) * ', '}"
+  #     p "#{day} -> #{transcripts.map(&:class).join(', ')}"
   #   end
   #   "2006-03-01 -> Transcript"
   #   "2006-02-28 -> Transcript"
@@ -19,22 +22,26 @@ module Enumerable
       (grouped[yield(element)] ||= []) << element
       grouped
     end
-  end if RUBY_VERSION < '1.9'
+  end unless [].respond_to?(:group_by)
 
   # Calculates a sum from the elements. Examples:
   #
   #  payments.sum { |p| p.price * p.tax_rate }
   #  payments.sum(&:price)
   #
-  # This is instead of payments.inject { |sum, p| sum + p.price }
+  # The latter is a shortcut for:
+  #
+  #  payments.inject { |sum, p| sum + p.price }
+  #
+  # It can also calculate the sum without the use of a block.
   #
-  # Also calculates sums without the use of a block:
-  #   [5, 15, 10].sum # => 30
+  #  [5, 15, 10].sum # => 30
+  #  ["foo", "bar"].sum # => "foobar"
+  #  [[1, 2], [3, 1, 5]].sum => [1, 2, 3, 1, 5]
   #
-  # The default identity (sum of an empty list) is zero. 
-  # However, you can override this default:
+  # The default sum of an empty list is zero. You can override this default:
   #
-  # [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
+  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
   #
   def sum(identity = 0, &block)
     return identity unless size > 0

data/lib/active_support/core_ext/exception.rb

@@ -1,3 +1,11 @@
+module ActiveSupport
+  if RUBY_VERSION >= '1.9'
+    FrozenObjectError = RuntimeError
+  else
+    FrozenObjectError = TypeError
+  end
+end
+
 class Exception # :nodoc:
   def clean_message
     Pathname.clean_within message

data/lib/active_support/core_ext/file.rb

@@ -3,16 +3,16 @@ require 'tempfile'
 # Write to a file atomically.  Useful for situations where you don't
 # want other processes or threads to see half-written files.
 #
-#  File.atomic_write("important.file") do |file|
-#    file.write("hello")
-#  end
+#   File.atomic_write("important.file") do |file|
+#     file.write("hello")
+#   end
 #
 # 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.imporant", "/data/tmp") do |f|
-#   file.write("hello")
-# end
+#   File.atomic_write("/data/something.important", "/data/tmp") do |f|
+#     file.write("hello")
+#   end
 def File.atomic_write(file_name, temp_dir = Dir.tmpdir)
   temp_file = Tempfile.new(File.basename(file_name), temp_dir)
   yield temp_file

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

@@ -24,10 +24,25 @@ class XmlSimple
   end
 end
 
+# 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
+
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Hash #:nodoc:
       module Conversions
+
         XML_TYPE_NAMES = {
           "Symbol"     => "symbol",
           "Fixnum"     => "integer",
@@ -55,19 +70,19 @@ module ActiveSupport #:nodoc:
           XML_PARSING = {
             "symbol"       => Proc.new  { |symbol|  symbol.to_sym },
             "date"         => Proc.new  { |date|    ::Date.parse(date) },
-            "datetime"     => Proc.new  { |time|    ::Time.parse(time).utc },
+            "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|     Base64.decode64(bin) },
-            # FIXME: Get rid of eval and institute a proper decorator here
+            "base64Binary" => Proc.new  { |bin|     ActiveSupport::Base64.decode64(bin) },
             "file"         => Proc.new do |file, entity|
-              f = StringIO.new(Base64.decode64(file))
-              eval "def f.original_filename() '#{entity["name"]}' || 'untitled' end"
-              eval "def f.content_type()      '#{entity["content_type"]}' || 'application/octet-stream' end"
+              f = StringIO.new(ActiveSupport::Base64.decode64(file))
+              f.extend(FileLike)
+              f.original_filename = entity['name']
+              f.content_type = entity['content_type']
               f
             end
           }
@@ -94,6 +109,8 @@ module ActiveSupport #:nodoc:
             value.to_query(namespace ? "#{namespace}[#{key}]" : key)
           end.sort * '&'
         end
+        
+        alias_method :to_param, :to_query
 
         def to_xml(options = {})
           options[:indent] ||= 2
@@ -194,8 +211,9 @@ module ActiveSupport #:nodoc:
                   elsif value.blank? || value['nil'] == 'true'
                     nil
                   # If the type is the only element which makes it then 
-                  # this still makes the value nil
-                  elsif value['type'] && value.size == 1
+                  # this still makes the value nil, except if type is
+                  # a XML node(where type['value'] is a Hash)
+                  elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
                     nil
                   else
                     xml_value = value.inject({}) do |h,(k,v)|

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

@@ -1,5 +1,6 @@
 # This class has dubious semantics and we only have it so that
 # people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
 
 class HashWithIndifferentAccess < Hash
   def initialize(constructor = {})
@@ -22,10 +23,25 @@ class HashWithIndifferentAccess < Hash
   alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
   alias_method :regular_update, :update unless method_defined?(:regular_update)
 
+  # Assigns a new value to the hash:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:key] = "value"
+  #
   def []=(key, value)
     regular_writer(convert_key(key), convert_value(value))
   end
 
+  # Updates the instantized hash with values from the second:
+  # 
+  #   hash_1 = HashWithIndifferentAccess.new
+  #   hash_1[:key] = "value"
+  # 
+  #   hash_2 = HashWithIndifferentAccess.new
+  #   hash_2[:key] = "New Value!"
+  # 
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  # 
   def update(other_hash)
     other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
     self
@@ -33,6 +49,13 @@ class HashWithIndifferentAccess < Hash
 
   alias_method :merge!, :update
 
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
   def key?(key)
     super(convert_key(key))
   end
@@ -41,22 +64,34 @@ class HashWithIndifferentAccess < Hash
   alias_method :has_key?, :key?
   alias_method :member?, :key?
 
+  # Fetches the value for the specified key, same as doing hash[key]
   def fetch(key, *extras)
     super(convert_key(key), *extras)
   end
 
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
   def values_at(*indices)
     indices.collect {|key| self[convert_key(key)]}
   end
 
+  # Returns an exact copy of the hash.
   def dup
     HashWithIndifferentAccess.new(self)
   end
 
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
   def merge(hash)
     self.dup.update(hash)
   end
 
+  # Removes a specified key from the hash.
   def delete(key)
     super(convert_key(key))
   end

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

@@ -8,12 +8,15 @@ module ActiveSupport #:nodoc:
       #     options.reverse_merge! :size => 25, :velocity => 10
       #   end
       #
-      # The default :size and :velocity is only set if the +options+ passed in doesn't already have those keys set.
+      # The default <tt>:size</tt> and <tt>:velocity</tt> is only set if the +options+ passed in doesn't already have those keys set.
       module ReverseMerge
+        # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
         def reverse_merge(other_hash)
           other_hash.merge(self)
         end
 
+        # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+        # Modifies the receiver in place.
         def reverse_merge!(other_hash)
           replace(reverse_merge(other_hash))
         end

data/lib/active_support/core_ext/integer/even_odd.rb

@@ -1,11 +1,16 @@
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Integer #:nodoc:
-      # For checking if a fixnum is even or odd. 
-      # * 1.even? # => false
-      # * 1.odd?  # => true
-      # * 2.even? # => true
-      # * 2.odd? # => false
+      # For checking if a fixnum is even or odd.
+      #
+      #   2.even?  # => true
+      #   2.odd?   # => false
+      #   1.even?  # => false
+      #   1.odd?   # => true
+      #   0.even?  # => true
+      #   0.odd?   # => false
+      #   -1.even? # => false
+      #   -1.odd?  # => true
       module EvenOdd
         def multiple_of?(number)
           self % number == 0

data/lib/active_support/core_ext/integer/inflections.rb

@@ -7,7 +7,6 @@ module ActiveSupport #:nodoc:
         # Ordinalize turns a number into an ordinal string used to denote the
         # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
         #
-        # Examples
         #   1.ordinalize    # => "1st"
         #   2.ordinalize    # => "2nd"
         #   1002.ordinalize # => "1002nd"

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

@@ -2,14 +2,6 @@ module Kernel
   # Turns the current script into a daemon process that detaches from the console.
   # It can be shut down with a TERM signal.
   def daemonize
-    exit if fork                   # Parent exits, child continues.
-    Process.setsid                 # Become session leader.
-    exit if fork                   # Zap session leader. See [1].
-    Dir.chdir "/"                  # Release old working directory.
-    File.umask 0000                # Ensure sensible umask. Adjust as needed.
-    STDIN.reopen "/dev/null"       # Free file descriptors and
-    STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
-    STDERR.reopen STDOUT           # STDOUT/ERR should better go to a logfile.
-    trap("TERM") { exit }
+    Process.daemon
   end
-end
+end