activesupport 2.1.2 → 2.2.2

data/lib/active_support/testing/setup_and_teardown.rb

@@ -10,19 +10,46 @@ module ActiveSupport
         end
 
       def self.included(base)
-        base.send :include, ActiveSupport::Callbacks
-        base.define_callbacks :setup, :teardown
+        base.class_eval do
+          include ActiveSupport::Callbacks
+          define_callbacks :setup, :teardown
 
+          if defined?(::Mini)
+            undef_method :run
+            alias_method :run, :run_with_callbacks_and_miniunit
+          else
+            begin
+              require 'mocha'
+              undef_method :run
+              alias_method :run, :run_with_callbacks_and_mocha
+            rescue LoadError
+              undef_method :run
+              alias_method :run, :run_with_callbacks_and_testunit
+            end
+          end
+        end
+      end
+
+      def run_with_callbacks_and_miniunit(runner)
+        result = '.'
         begin
-          require 'mocha'
-          base.alias_method_chain :run, :callbacks_and_mocha
-        rescue LoadError
-          base.alias_method_chain :run, :callbacks
+          run_callbacks :setup
+          result = super
+        rescue Exception => e
+          result = runner.puke(self.class, self.name, e)
+        ensure
+          begin
+            teardown
+            run_callbacks :teardown, :enumerator => :reverse_each
+          rescue Exception => e
+            result = runner.puke(self.class, self.name, e)
+          end
         end
+        result
       end
 
       # This redefinition is unfortunate but test/unit shows us no alternative.
-      def run_with_callbacks(result) #:nodoc:
+      def run_with_callbacks_and_testunit(result) #:nodoc:
         return if @method_name.to_s == "default_test"
 
         yield(Test::Unit::TestCase::STARTED, name)

data/lib/active_support/time_with_zone.rb

@@ -1,6 +1,6 @@
 require 'tzinfo'
 module ActiveSupport
-  # A Time-like class that can represent a time in any time zone. Necessary because standard Ruby Time instances are 
+  # A Time-like class that can represent a time in any time zone. Necessary because standard Ruby Time instances are
   # limited to UTC and the system's <tt>ENV['TZ']</tt> zone.
   #
   # You shouldn't ever need to create a TimeWithZone instance directly via <tt>new</tt> -- instead, Rails provides the methods
@@ -32,12 +32,12 @@ module ActiveSupport
   class TimeWithZone
     include Comparable
     attr_reader :time_zone
-  
+
     def initialize(utc_time, time_zone, local_time = nil, period = nil)
       @utc, @time_zone, @time = utc_time, time_zone, local_time
       @period = @utc ? period : get_period_and_ensure_valid_local_time
     end
-  
+
     # Returns a Time or DateTime instance that represents the time in +time_zone+.
     def time
       @time ||= period.to_local(@utc)
@@ -51,7 +51,7 @@ module ActiveSupport
     alias_method :getgm, :utc
     alias_method :getutc, :utc
     alias_method :gmtime, :utc
-  
+
     # Returns the underlying TZInfo::TimezonePeriod.
     def period
       @period ||= time_zone.period_for_utc(@utc)
@@ -62,38 +62,38 @@ module ActiveSupport
       return self if time_zone == new_zone
       utc.in_time_zone(new_zone)
     end
-  
+
     # Returns a <tt>Time.local()</tt> instance of the simultaneous time in your system's <tt>ENV['TZ']</tt> zone
     def localtime
       utc.getlocal
     end
     alias_method :getlocal, :localtime
-  
+
     def dst?
       period.dst?
     end
     alias_method :isdst, :dst?
-  
+
     def utc?
       time_zone.name == 'UTC'
     end
     alias_method :gmt?, :utc?
-  
+
     def utc_offset
       period.utc_total_offset
     end
     alias_method :gmt_offset, :utc_offset
     alias_method :gmtoff, :utc_offset
-  
+
     def formatted_offset(colon = true, alternate_utc_string = nil)
       utc? && alternate_utc_string || utc_offset.to_utc_offset_s(colon)
     end
-  
+
     # Time uses +zone+ to display the time zone abbreviation, so we're duck-typing it.
     def zone
       period.zone_identifier.to_s
     end
-  
+
     def inspect
       "#{time.strftime('%a, %d %b %Y %H:%M:%S')} #{zone} #{formatted_offset}"
     end
@@ -102,7 +102,19 @@ module ActiveSupport
       "#{time.strftime("%Y-%m-%dT%H:%M:%S")}#{formatted_offset(true, 'Z')}"
     end
     alias_method :iso8601, :xmlschema
-  
+
+    # Returns a JSON string representing the TimeWithZone. If ActiveSupport.use_standard_json_time_format is set to
+    # true, the ISO 8601 format is used.
+    #
+    # ==== Examples:
+    #
+    #   # With ActiveSupport.use_standard_json_time_format = true
+    #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
+    #   # => "2005-02-01T15:15:10Z"
+    #
+    #   # With ActiveSupport.use_standard_json_time_format = false
+    #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
+    #   # => "2005/02/01 15:15:10 +0000"
     def to_json(options = nil)
       if ActiveSupport.use_standard_json_time_format
         xmlschema.inspect
@@ -110,7 +122,7 @@ module ActiveSupport
         %("#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)}")
       end
     end
-    
+
     def to_yaml(options = {})
       if options.kind_of?(YAML::Emitter)
         utc.to_yaml(options)
@@ -118,19 +130,19 @@ module ActiveSupport
         time.to_yaml(options).gsub('Z', formatted_offset(true, 'Z'))
       end
     end
-    
+
     def httpdate
       utc.httpdate
     end
-  
+
     def rfc2822
       to_s(:rfc822)
     end
     alias_method :rfc822, :rfc2822
-  
+
     # <tt>:db</tt> format outputs time in UTC; all others output time in local.
     # Uses TimeWithZone's +strftime+, so <tt>%Z</tt> and <tt>%z</tt> work correctly.
-    def to_s(format = :default) 
+    def to_s(format = :default)
       return utc.to_s(format) if format == :db
       if formatter = ::Time::DATE_FORMATS[format]
         formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
@@ -138,27 +150,39 @@ module ActiveSupport
         "#{time.strftime("%Y-%m-%d %H:%M:%S")} #{formatted_offset(false, 'UTC')}" # mimicking Ruby 1.9 Time#to_s format
       end
     end
-    
+
     # Replaces <tt>%Z</tt> and <tt>%z</tt> directives with +zone+ and +formatted_offset+, respectively, before passing to
     # Time#strftime, so that zone information is correct
     def strftime(format)
       format = format.gsub('%Z', zone).gsub('%z', formatted_offset(false))
       time.strftime(format)
     end
-  
+
     # Use the time in UTC for comparisons.
     def <=>(other)
       utc <=> other
     end
-    
+
     def between?(min, max)
       utc.between?(min, max)
     end
-    
+
+    def past?
+      utc.past?
+    end
+
+    def today?
+      time.today?
+    end
+
+    def future?
+      utc.future?
+    end
+
     def eql?(other)
       utc == other
     end
-    
+
     def +(other)
       # If we're adding a Duration of variable length (i.e., years, months, days), move forward from #time,
       # otherwise move forward from #utc, for accuracy when moving across DST boundaries
@@ -182,7 +206,7 @@ module ActiveSupport
         result.in_time_zone(time_zone)
       end
     end
-    
+
     def since(other)
       # If we're adding a Duration of variable length (i.e., years, months, days), move forward from #time,
       # otherwise move forward from #utc, for accuracy when moving across DST boundaries
@@ -192,7 +216,7 @@ module ActiveSupport
         utc.since(other).in_time_zone(time_zone)
       end
     end
-    
+
     def ago(other)
       since(-other)
     end
@@ -206,47 +230,47 @@ module ActiveSupport
         utc.advance(options).in_time_zone(time_zone)
       end
     end
-    
-    %w(year mon month day mday hour min sec).each do |method_name|
+
+    %w(year mon month day mday wday yday hour min sec to_date).each do |method_name|
       class_eval <<-EOV
         def #{method_name}
           time.#{method_name}
         end
       EOV
     end
-    
+
     def usec
       time.respond_to?(:usec) ? time.usec : 0
     end
-    
+
     def to_a
       [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
     end
-    
+
     def to_f
       utc.to_f
-    end    
-    
+    end
+
     def to_i
       utc.to_i
     end
     alias_method :hash, :to_i
     alias_method :tv_sec, :to_i
-  
+
     # A TimeWithZone acts like a Time, so just return +self+.
     def to_time
       self
     end
-    
+
     def to_datetime
       utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
     end
-    
+
     # So that +self+ <tt>acts_like?(:time)</tt>.
     def acts_like_time?
       true
     end
-  
+
     # Say we're a Time to thwart type checking.
     def is_a?(klass)
       klass == ::Time || super
@@ -261,9 +285,9 @@ module ActiveSupport
     def marshal_dump
       [utc, time_zone.name, time]
     end
-    
+
     def marshal_load(variables)
-      initialize(variables[0].utc, ::Time.send!(:get_zone, variables[1]), variables[2].utc)
+      initialize(variables[0].utc, ::Time.__send__(:get_zone, variables[1]), variables[2].utc)
     end
 
     # Ensure proxy class responds to all methods that underlying time instance responds to.
@@ -278,10 +302,10 @@ module ActiveSupport
       result = time.__send__(sym, *args, &block)
       result.acts_like?(:time) ? self.class.new(nil, time_zone, result) : result
     end
-    
-    private      
+
+    private
       def get_period_and_ensure_valid_local_time
-        # we don't want a Time.local instance enforcing its own DST rules as well, 
+        # we don't want a Time.local instance enforcing its own DST rules as well,
         # so transfer time values to a utc constructor if necessary
         @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
         begin
@@ -292,11 +316,11 @@ module ActiveSupport
           retry
         end
       end
-      
+
       def transfer_time_values_to_utc_constructor(time)
         ::Time.utc_time(time.year, time.month, time.day, time.hour, time.min, time.sec, time.respond_to?(:usec) ? time.usec : 0)
       end
-      
+
       def duration_of_variable_length?(obj)
         ActiveSupport::Duration === obj && obj.parts.flatten.detect {|p| [:years, :months, :days].include? p }
       end

data/lib/active_support/values/time_zone.rb

@@ -124,7 +124,7 @@ module ActiveSupport
         "Kathmandu"                    => "Asia/Katmandu",
         "Astana"                       => "Asia/Dhaka",
         "Dhaka"                        => "Asia/Dhaka",
-        "Sri Jayawardenepura"          => "Asia/Dhaka",
+        "Sri Jayawardenepura"          => "Asia/Colombo",
         "Almaty"                       => "Asia/Almaty",
         "Novosibirsk"                  => "Asia/Novosibirsk",
         "Rangoon"                      => "Asia/Rangoon",
@@ -201,6 +201,12 @@ module ActiveSupport
       result
     end
 
+    # Compare #name and TZInfo identifier to a supplied regexp, returning true
+    # if a match is found.
+    def =~(re)
+      return true if name =~ re || MAPPING[name] =~ re
+    end
+
     # Returns a textual representation of this time zone.
     def to_s
       "(GMT#{formatted_offset}) #{name}"
@@ -298,7 +304,8 @@ module ActiveSupport
                  "Mexico City", "Monterrey", "Central America" ],
        [-18_000, "Eastern Time (US & Canada)", "Indiana (East)", "Bogota",
                  "Lima", "Quito" ],
-       [-14_400, "Atlantic Time (Canada)", "Caracas", "La Paz", "Santiago" ],
+       [-16_200, "Caracas" ],
+       [-14_400, "Atlantic Time (Canada)", "La Paz", "Santiago" ],
        [-12_600, "Newfoundland" ],
        [-10_800, "Brasilia", "Buenos Aires", "Georgetown", "Greenland" ],
        [ -7_200, "Mid-Atlantic" ],
@@ -319,9 +326,9 @@ module ActiveSupport
        [ 14_400, "Abu Dhabi", "Muscat", "Baku", "Tbilisi", "Yerevan" ],
        [ 16_200, "Kabul" ],
        [ 18_000, "Ekaterinburg", "Islamabad", "Karachi", "Tashkent" ],
-       [ 19_800, "Chennai", "Kolkata", "Mumbai", "New Delhi" ],
+       [ 19_800, "Chennai", "Kolkata", "Mumbai", "New Delhi", "Sri Jayawardenepura" ],
        [ 20_700, "Kathmandu" ],
-       [ 21_600, "Astana", "Dhaka", "Sri Jayawardenepura", "Almaty",
+       [ 21_600, "Astana", "Dhaka", "Almaty",
                  "Novosibirsk" ],
        [ 23_400, "Rangoon" ],
        [ 25_200, "Bangkok", "Hanoi", "Jakarta", "Krasnoyarsk" ],

data/lib/active_support/vendor.rb

@@ -14,13 +14,21 @@ rescue Gem::LoadError
 end
 
 begin
-  gem 'memcache-client', '~> 1.5.0'
+  gem 'memcache-client', '~> 1.5.1'
 rescue Gem::LoadError
-  $:.unshift "#{File.dirname(__FILE__)}/vendor/memcache-client-1.5.0"
+  $:.unshift "#{File.dirname(__FILE__)}/vendor/memcache-client-1.5.1"
 end
 
 begin
-  gem 'tzinfo', '~> 0.3.11'
+  gem 'tzinfo', '~> 0.3.12'
 rescue Gem::LoadError
-  $:.unshift "#{File.dirname(__FILE__)}/vendor/tzinfo-0.3.11"
-end
+  $:.unshift "#{File.dirname(__FILE__)}/vendor/tzinfo-0.3.12"
+end
+
+# TODO I18n gem has not been released yet
+# begin
+#   gem 'i18n', '~> 0.0.1'
+# rescue Gem::LoadError
+  $:.unshift "#{File.dirname(__FILE__)}/vendor/i18n-0.0.1"
+  require 'i18n'
+# end

data/lib/active_support/vendor/builder-2.1.2/builder/xmlevents.rb

@@ -20,7 +20,7 @@ module Builder
   # markup.
   #
   # Usage:
-  #   xe = Builder::XmlEvents.new(hander)
+  #   xe = Builder::XmlEvents.new(handler)
   #   xe.title("HI")    # Sends start_tag/end_tag/text messages to the handler.
   #
   # Indentation may also be selected by providing value for the

data/lib/active_support/vendor/i18n-0.0.1/i18n.rb

@@ -0,0 +1,194 @@
+# Authors::   Matt Aimonetti (http://railsontherun.com/),
+#             Sven Fuchs (http://www.artweb-design.de),
+#             Joshua Harvey (http://www.workingwithrails.com/person/759-joshua-harvey),
+#             Saimon Moore (http://saimonmoore.net),
+#             Stephan Soller (http://www.arkanis-development.de/) 
+# Copyright:: Copyright (c) 2008 The Ruby i18n Team
+# License::   MIT
+require 'i18n/backend/simple'
+require 'i18n/exceptions'
+
+module I18n  
+  @@backend = nil
+  @@load_path = nil
+  @@default_locale = :'en'
+  @@exception_handler = :default_exception_handler
+    
+  class << self
+    # Returns the current backend. Defaults to +Backend::Simple+.
+    def backend
+      @@backend ||= Backend::Simple.new
+    end
+    
+    # Sets the current backend. Used to set a custom backend.
+    def backend=(backend) 
+      @@backend = backend
+    end
+  
+    # Returns the current default locale. Defaults to 'en'
+    def default_locale
+      @@default_locale 
+    end
+    
+    # Sets the current default locale. Used to set a custom default locale.
+    def default_locale=(locale) 
+      @@default_locale = locale 
+    end
+    
+    # Returns the current locale. Defaults to I18n.default_locale.
+    def locale
+      Thread.current[:locale] ||= default_locale
+    end
+
+    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
+    def locale=(locale)
+      Thread.current[:locale] = locale
+    end
+    
+    # Sets the exception handler.
+    def exception_handler=(exception_handler)
+      @@exception_handler = exception_handler
+    end
+    
+    # Allow clients to register paths providing translation data sources. The
+    # backend defines acceptable sources.
+    #
+    # E.g. the provided SimpleBackend accepts a list of paths to translation
+    # files which are either named *.rb and contain plain Ruby Hashes or are
+    # named *.yml and contain YAML data. So for the SimpleBackend clients may
+    # register translation files like this:
+    #   I18n.load_path << 'path/to/locale/en.yml'
+    def load_path
+      @@load_path ||= []
+    end
+
+    # Sets the load path instance. Custom implementations are expected to
+    # behave like a Ruby Array.
+    def load_path=(load_path)
+      @@load_path = load_path
+    end
+
+    # Tells the backend to reload translations. Used in situations like the
+    # Rails development environment. Backends can implement whatever strategy
+    # is useful.
+    def reload!
+      backend.reload!
+    end
+    
+    # Translates, pluralizes and interpolates a given key using a given locale, 
+    # scope, and default, as well as interpolation values.
+    #
+    # *LOOKUP*
+    #
+    # Translation data is organized as a nested hash using the upper-level keys 
+    # as namespaces. <em>E.g.</em>, ActionView ships with the translation: 
+    # <tt>:date => {:formats => {:short => "%b %d"}}</tt>.
+    # 
+    # Translations can be looked up at any level of this hash using the key argument 
+    # and the scope option. <em>E.g.</em>, in this example <tt>I18n.t :date</tt> 
+    # returns the whole translations hash <tt>{:formats => {:short => "%b %d"}}</tt>.
+    # 
+    # Key can be either a single key or a dot-separated key (both Strings and Symbols 
+    # work). <em>E.g.</em>, the short format can be looked up using both:
+    #   I18n.t 'date.formats.short'
+    #   I18n.t :'date.formats.short'
+    # 
+    # Scope can be either a single key, a dot-separated key or an array of keys
+    # or dot-separated keys. Keys and scopes can be combined freely. So these
+    # examples will all look up the same short date format:
+    #   I18n.t 'date.formats.short'
+    #   I18n.t 'formats.short', :scope => 'date'
+    #   I18n.t 'short', :scope => 'date.formats'
+    #   I18n.t 'short', :scope => %w(date formats)
+    #
+    # *INTERPOLATION*
+    #
+    # Translations can contain interpolation variables which will be replaced by
+    # values passed to #translate as part of the options hash, with the keys matching
+    # the interpolation variable names. 
+    #
+    # <em>E.g.</em>, with a translation <tt>:foo => "foo {{bar}}"</tt> the option 
+    # value for the key +bar+ will be interpolated into the translation:
+    #   I18n.t :foo, :bar => 'baz' # => 'foo baz'
+    #
+    # *PLURALIZATION*
+    #
+    # Translation data can contain pluralized translations. Pluralized translations
+    # are arrays of singluar/plural versions of translations like <tt>['Foo', 'Foos']</tt>.
+    #
+    # Note that <tt>I18n::Backend::Simple</tt> only supports an algorithm for English 
+    # pluralization rules. Other algorithms can be supported by custom backends.
+    #
+    # This returns the singular version of a pluralized translation:
+    #   I18n.t :foo, :count => 1 # => 'Foo'
+    #
+    # These both return the plural version of a pluralized translation:
+    #   I18n.t :foo, :count => 0 # => 'Foos'
+    #   I18n.t :foo, :count => 2 # => 'Foos'
+    # 
+    # The <tt>:count</tt> option can be used both for pluralization and interpolation. 
+    # <em>E.g.</em>, with the translation 
+    # <tt>:foo => ['{{count}} foo', '{{count}} foos']</tt>, count will
+    # be interpolated to the pluralized translation:
+    #   I18n.t :foo, :count => 1 # => '1 foo'
+    #
+    # *DEFAULTS*
+    #
+    # This returns the translation for <tt>:foo</tt> or <tt>default</tt> if no translation was found:
+    #   I18n.t :foo, :default => 'default'
+    #
+    # This returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt> if no 
+    # translation for <tt>:foo</tt> was found:
+    #   I18n.t :foo, :default => :bar
+    #
+    # Returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt> 
+    # or <tt>default</tt> if no translations for <tt>:foo</tt> and <tt>:bar</tt> were found.
+    #   I18n.t :foo, :default => [:bar, 'default']
+    #
+    # <b>BULK LOOKUP</b>
+    #
+    # This returns an array with the translations for <tt>:foo</tt> and <tt>:bar</tt>.
+    #   I18n.t [:foo, :bar]
+    #
+    # Can be used with dot-separated nested keys:
+    #   I18n.t [:'baz.foo', :'baz.bar']
+    #
+    # Which is the same as using a scope option:
+    #   I18n.t [:foo, :bar], :scope => :baz
+    def translate(key, options = {})
+      locale = options.delete(:locale) || I18n.locale
+      backend.translate(locale, key, options)
+    rescue I18n::ArgumentError => e
+      raise e if options[:raise]
+      send(@@exception_handler, e, locale, key, options)
+    end        
+    alias :t :translate
+    
+    # Localizes certain objects, such as dates and numbers to local formatting.
+    def localize(object, options = {})
+      locale = options[:locale] || I18n.locale
+      format = options[:format] || :default
+      backend.localize(locale, object, format)
+    end
+    alias :l :localize
+    
+  protected
+    # Handles exceptions raised in the backend. All exceptions except for
+    # MissingTranslationData exceptions are re-raised. When a MissingTranslationData
+    # was caught and the option :raise is not set the handler returns an error
+    # message string containing the key/scope.
+    def default_exception_handler(exception, locale, key, options)
+      return exception.message if MissingTranslationData === exception
+      raise exception
+    end
+          
+    # Merges the given locale, key and scope into a single array of keys.
+    # Splits keys that contain dots into multiple keys. Makes sure all
+    # keys are Symbols.
+    def normalize_translation_keys(locale, key, scope)
+      keys = [locale] + Array(scope) + [key]
+      keys = keys.map { |k| k.to_s.split(/\./) }
+      keys.flatten.map { |k| k.to_sym }
+    end
+  end
+end