activesupport 1.4.4 → 2.0.0

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

@@ -4,29 +4,90 @@ module ActiveSupport #:nodoc:
       # Getting times in different convenient string representations and other objects
       module Conversions
         DATE_FORMATS = {
-          :db     => "%Y-%m-%d %H:%M:%S",
-          :short  => "%d %b %H:%M",
-          :long   => "%B %d, %Y %H:%M",
-          :rfc822 => "%a, %d %b %Y %H:%M:%S %z"
+          :db           => "%Y-%m-%d %H:%M:%S",
+          :time         => "%H:%M",
+          :short        => "%d %b %H:%M",
+          :long         => "%B %d, %Y %H:%M",
+          :long_ordinal => lambda { |time| time.strftime("%B #{time.day.ordinalize}, %Y %H:%M") },
+          :rfc822       => "%a, %d %b %Y %H:%M:%S %z"
         }
 
-        def self.included(klass)
-          klass.send(:alias_method, :to_default_s, :to_s)
-          klass.send(:alias_method, :to_s, :to_formatted_s)
+        def self.included(base)
+          base.class_eval do
+            alias_method :to_default_s, :to_s
+            alias_method :to_s, :to_formatted_s
+          end
         end
-        
+
+        # Convert to a formatted string - see DATE_FORMATS for predefined formats.
+        # You can also add your own formats to the DATE_FORMATS constant and use them with this method.
+        #
+        # This method is also aliased as <tt>to_s</tt>.
+        #
+        # ==== Examples:
+        #   time = Time.now                     # => Thu Jan 18 06:10:17 CST 2007
+        #
+        #   time.to_formatted_s(:time)          # => "06:10:17"
+        #   time.to_s(:time)                    # => "06:10:17"
+        #
+        #   time.to_formatted_s(:db)            # => "2007-01-18 06:10:17"
+        #   time.to_formatted_s(:short)         # => "18 Jan 06:10"
+        #   time.to_formatted_s(:long)          # => "January 18, 2007 06:10"
+        #   time.to_formatted_s(:long_ordinal)  # => "January 18th, 2007 06:10"
+        #   time.to_formatted_s(:rfc822)        # => "Thu, 18 Jan 2007 06:10:17 -0600"
         def to_formatted_s(format = :default)
-          DATE_FORMATS[format] ? strftime(DATE_FORMATS[format]).strip : to_default_s          
+          if formatter = DATE_FORMATS[format]
+            if formatter.respond_to?(:call)
+              formatter.call(self).to_s
+            else
+              strftime(formatter)
+            end
+          else
+            to_default_s
+          end
         end
 
+        # Convert a Time object to a Date, dropping hour, minute, and second precision.
+        #
+        # ==== Examples
+        #   my_time = Time.now
+        #   # => Mon Nov 12 22:59:51 -0500 2007
+        #
+        #   my_time.to_date
+        #   #=> Mon, 12 Nov 2007
+        #
+        #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")
+        #   # => Tue Jan 13 13:13:03 -0500 2009
+        #
+        #   your_time.to_date
+        #   # => Tue, 13 Jan 2009
         def to_date
           ::Date.new(year, month, day)
         end
 
-        # To be able to keep Dates and Times interchangeable on conversions
+        # A method to keep Time, Date and DateTime instances interchangeable on conversions.
+        # In this case, it simply returns +self+.
         def to_time
           self
         end
+
+        # Converts a Time instance to a Ruby DateTime instance, preserving UTC offset.
+        #
+        # ==== Examples
+        #   my_time = Time.now
+        #   # => Mon Nov 12 23:04:21 -0500 2007
+        #
+        #   my_time.to_datetime
+        #   # => Mon, 12 Nov 2007 23:04:21 -0500
+        #
+        #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")
+        #   # => Tue Jan 13 13:13:03 -0500 2009
+        #
+        #   your_time.to_datetime
+        #   # => Tue, 13 Jan 2009 13:13:03 -0500
+        def to_datetime
+          ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400))
+        end
       end
     end
   end

data/lib/active_support/dependencies.rb

@@ -1,7 +1,7 @@
 require 'set'
-require File.dirname(__FILE__) + '/core_ext/module/attribute_accessors'
-require File.dirname(__FILE__) + '/core_ext/load_error'
-require File.dirname(__FILE__) + '/core_ext/kernel'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/load_error'
+require 'active_support/core_ext/kernel'
 
 module Dependencies #:nodoc:
   extend self
@@ -114,7 +114,7 @@ module Dependencies #:nodoc:
     raise NameError, "#{path.inspect} is not a valid constant name!" unless
       /^(::)?([A-Z]\w*)(::[A-Z]\w*)*$/ =~ path
     
-    names = path.split('::')
+    names = path.to_s.split('::')
     names.shift if names.first.empty?
     
     # We can't use defined? because it will invoke const_missing for the parent
@@ -229,10 +229,10 @@ module Dependencies #:nodoc:
         from_mod = Object
       end
     end
-    
+
     # If we have an anonymous module, all we can do is attempt to load from Object.
-    from_mod = Object if from_mod.name.empty?
-    
+    from_mod = Object if from_mod.name.blank?
+
     unless qualified_const_defined?(from_mod.name) && from_mod.name.constantize.object_id == from_mod.object_id
       raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
     end
@@ -383,7 +383,7 @@ module Dependencies #:nodoc:
   
   class LoadingModule #:nodoc:
     # Old style environment.rb referenced this method directly.  Please note, it doesn't
-    # actualy *do* anything any more.
+    # actually *do* anything any more.
     def self.root(*args)
       if defined?(RAILS_DEFAULT_LOGGER)
         RAILS_DEFAULT_LOGGER.warn "Your environment.rb uses the old syntax, it may not continue to work in future releases."
@@ -392,11 +392,9 @@ module Dependencies #:nodoc:
     end
   end
 
-protected
-  
   # Convert the provided const desc to a qualified constant name (as a string).
   # A module, class, symbol, or string may be provided.
-  def to_constant_name(desc)
+  def to_constant_name(desc) #:nodoc:
     name = case desc
       when String then desc.starts_with?('::') ? desc[2..-1] : desc
       when Symbol then desc.to_s
@@ -406,23 +404,24 @@ protected
       else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
     end
   end
-  
-  def remove_constant(const)
+
+  def remove_constant(const) #:nodoc:
     return false unless qualified_const_defined? const
-    
+
     const = $1 if /\A::(.*)\Z/ =~ const.to_s
-    names = const.split('::')
+    names = const.to_s.split('::')
     if names.size == 1 # It's under Object
       parent = Object
     else
       parent = (names[0..-2] * '::').constantize
     end
-    
+
     log "removing constant #{const}"
-    parent.send :remove_const, names.last
+    parent.instance_eval { remove_const names.last }
     return true
   end
-  
+
+protected
   def log_call(*args)
     arg_str = args.collect(&:inspect) * ', '
     /in `([a-z_\?\!]+)'/ =~ caller(1).first
@@ -438,9 +437,11 @@ protected
   
 end
 
-Object.send(:define_method, :require_or_load)     { |file_name| Dependencies.require_or_load(file_name) } unless Object.respond_to?(:require_or_load)
-Object.send(:define_method, :require_dependency)  { |file_name| Dependencies.depend_on(file_name) }       unless Object.respond_to?(:require_dependency)
-Object.send(:define_method, :require_association) { |file_name| Dependencies.associate_with(file_name) }  unless Object.respond_to?(:require_association)
+Object.instance_eval do
+  define_method(:require_or_load)     { |file_name| Dependencies.require_or_load(file_name) } unless Object.respond_to?(:require_or_load)
+  define_method(:require_dependency)  { |file_name| Dependencies.depend_on(file_name) }       unless Object.respond_to?(:require_dependency)
+  define_method(:require_association) { |file_name| Dependencies.associate_with(file_name) }  unless Object.respond_to?(:require_association)
+end
 
 class Module #:nodoc:
   # Rename the original handler so we can chain it to the new one
@@ -480,18 +481,18 @@ class Class
   end
 end
 
-class Object #:nodoc:
+class Object
   
   alias_method :load_without_new_constant_marking, :load
   
-  def load(file, *extras)
+  def load(file, *extras) #:nodoc:
     Dependencies.new_constants_in(Object) { super(file, *extras) }
   rescue Exception => exception  # errors from loading file
     exception.blame_file! file
     raise
   end
 
-  def require(file, *extras)
+  def require(file, *extras) #:nodoc:
     Dependencies.new_constants_in(Object) { super(file, *extras) }
   rescue Exception => exception  # errors from required file
     exception.blame_file! file

data/lib/active_support/deprecation.rb

@@ -85,7 +85,7 @@ module ActiveSupport
     module ClassMethods #:nodoc:
       # Declare that a method has been deprecated.
       def deprecate(*method_names)
-        options = method_names.last.is_a?(Hash) ? method_names.pop : {}
+        options = method_names.extract_options!
         method_names = method_names + options.keys
         method_names.each do |method_name|
           alias_method_chain(method_name, :deprecation) do |target, punctuation|
@@ -147,7 +147,9 @@ module ActiveSupport
     # Stand-in for @request, @attributes, @params, etc which emits deprecation
     # warnings on any method call (except #inspect).
     class DeprecatedInstanceVariableProxy #:nodoc:
-      instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+      silence_warnings do
+        instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+      end
 
       def initialize(instance, method, var = "@#{method}")
         @instance, @method, @var = instance, method, var

data/lib/active_support/duration.rb

@@ -0,0 +1,86 @@
+module ActiveSupport
+  # Provides accurate date and time measurements using Date#advance and 
+  # Time#advance, respectively. It mainly supports the methods on Numeric,
+  # such as in this example:
+  #
+  #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
+  class Duration < BasicObject
+    attr_accessor :value, :parts
+    
+    def initialize(value, parts) #:nodoc:
+      @value, @parts = value, parts
+    end
+    
+    # Adds another Duration or a Numeric to this Duration. Numeric values
+    # are treated as seconds.
+    def +(other)
+      if Duration === other
+        Duration.new(value + other.value, @parts + other.parts)
+      else
+        Duration.new(value + other, @parts + [[:seconds, other]])
+      end
+    end
+    
+    # Subtracts another Duration or a Numeric from this Duration. Numeric
+    # values are treated as seconds.
+    def -(other)
+      self + (-other)
+    end
+    
+    def -@ #:nodoc:
+      Duration.new(-value, parts.map { |type,number| [type, -number] })
+    end
+    
+    def is_a?(klass) #:nodoc:
+      klass == Duration || super
+    end
+    
+    def self.===(other) #:nodoc:
+      other.is_a?(Duration) rescue super
+    end
+    
+    # Calculates a new Time or Date that is as far in the future
+    # as this Duration represents.
+    def since(time = ::Time.now)
+      sum(1, time)
+    end
+    alias :from_now :since
+    
+    # Calculates a new Time or Date that is as far in the past
+    # as this Duration represents.
+    def ago(time = ::Time.now)
+      sum(-1, time)
+    end
+    alias :until :ago
+    
+    def inspect #:nodoc:
+      consolidated = parts.inject(Hash.new(0)) { |h,part| h[part.first] += part.last; h }
+      [:years, :months, :days, :minutes, :seconds].map do |length|
+        n = consolidated[length]
+        "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
+      end.compact.to_sentence
+    end
+    
+    protected
+    
+    def sum(sign, time = ::Time.now) #:nodoc:
+      parts.inject(time) do |t,(type,number)|
+        if t.acts_like?(:time) || t.acts_like?(:date)
+          if type == :seconds
+            t.since(sign * number)
+          else
+            t.advance(type => sign * number)
+          end
+        else
+          raise ArgumentError, "expected a time or date, got #{time.inspect}"
+        end
+      end
+    end
+    
+    private
+    
+    def method_missing(method, *args, &block) #:nodoc:
+      value.send(method, *args)
+    end
+  end
+end

data/lib/active_support/inflections.rb

@@ -12,7 +12,7 @@ Inflector.inflections do |inflect|
   inflect.plural(/(hive)$/i, '\1s')
   inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
   inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
-  inflect.plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+  inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
   inflect.plural(/([m|l])ouse$/i, '\1ice')
   inflect.plural(/^(ox)$/i, '\1en')
   inflect.plural(/(quiz)$/i, '\1zes')
@@ -47,6 +47,7 @@ Inflector.inflections do |inflect|
   inflect.irregular('child', 'children')
   inflect.irregular('sex', 'sexes')
   inflect.irregular('move', 'moves')
+  inflect.irregular('cow', 'kine')
 
   inflect.uncountable(%w(equipment information rice money species series fish sheep))
 end

data/lib/active_support/inflector.rb

@@ -47,8 +47,15 @@ module Inflector
     #   irregular 'octopus', 'octopi'
     #   irregular 'person', 'people'
     def irregular(singular, plural)
-      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
-      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+      if singular[0,1].upcase == plural[0,1].upcase
+        plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+        singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+      else
+        plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+        plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+        singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1])
+        singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1])       
+      end
     end
 
     # Add uncountable words that shouldn't be attempted inflected.
@@ -99,7 +106,7 @@ module Inflector
   def pluralize(word)
     result = word.to_s.dup
 
-    if inflections.uncountables.include?(result.downcase)
+    if word.empty? || inflections.uncountables.include?(result.downcase)
       result
     else
       inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
@@ -263,9 +270,9 @@ module Inflector
       "#{number}th"
     else
       case number.to_i % 10
-        when 1: "#{number}st"
-        when 2: "#{number}nd"
-        when 3: "#{number}rd"
+        when 1; "#{number}st"
+        when 2; "#{number}nd"
+        when 3; "#{number}rd"
         else    "#{number}th"
       end
     end

data/lib/active_support/json.rb

@@ -1,48 +1,31 @@
-require 'active_support/json/encoders'
+require 'active_support/json/encoding'
+require 'active_support/json/decoding'
 
 module ActiveSupport
-  module JSON #:nodoc:
-    class CircularReferenceError < StandardError #:nodoc:
-    end
-    
-    # A string that returns itself as as its JSON-encoded form.
-    class Variable < String #:nodoc:
-      def to_json
-        self
-      end
-    end
-    
-    # When +true+, Hash#to_json will omit quoting string or symbol keys
-    # if the keys are valid JavaScript identifiers.  Note that this is
-    # technically improper JSON (all object keys must be quoted), so if
-    # you need strict JSON compliance, set this option to +false+.
-    mattr_accessor :unquote_hash_key_identifiers
-    @@unquote_hash_key_identifiers = true
+  module JSON
+    RESERVED_WORDS = %w(
+      abstract      delete        goto          private       transient
+      boolean       do            if            protected     try
+      break         double        implements    public        typeof
+      byte          else          import        return        var
+      case          enum          in            short         void
+      catch         export        instanceof    static        volatile
+      char          extends       int           super         while
+      class         final         interface     switch        with
+      const         finally       long          synchronized
+      continue      float         native        this
+      debugger      for           new           throw
+      default       function      package       throws
+    ) #:nodoc:
 
     class << self
-      REFERENCE_STACK_VARIABLE = :json_reference_stack
-      
-      def encode(value)
-        raise_on_circular_reference(value) do
-          Encoders[value.class].call(value)
-        end
+      def valid_identifier?(key) #:nodoc:
+        key.to_s =~ /^[[:alpha:]_$][[:alnum:]_$]*$/ && !reserved_word?(key)
       end
-      
-      def can_unquote_identifier?(key)
-        return false unless unquote_hash_key_identifiers
-        key.to_s =~ /^[[:alpha:]_$][[:alnum:]_$]*$/
+
+      def reserved_word?(key) #:nodoc:
+        RESERVED_WORDS.include?(key.to_s)
       end
-      
-      protected
-        def raise_on_circular_reference(value)
-          stack = Thread.current[REFERENCE_STACK_VARIABLE] ||= []
-          raise CircularReferenceError, 'object references itself' if
-            stack.include? value
-          stack << value
-          yield
-        ensure
-          stack.pop
-        end
     end
   end
 end