activesupport 3.0.0.beta2 → 3.0.0.beta3

data/CHANGELOG

@@ -1,3 +1,10 @@
+*Rails 3.0.0 [beta 3] (April 13th, 2010)*
+
+* Improve transliteration quality.  #4374 [Norman Clarke]
+
+* Speed up and add Ruby 1.9 support for ActiveSupport::Multibyte::Chars#tidy_bytes.  #4350 [Norman Clarke]
+
+
 *Rails 3.0.0 [beta 2] (April 1st, 2010)*
 
 * Reduced load time by deferring configuration of classes using

data/lib/active_support/backtrace_cleaner.rb

@@ -4,7 +4,9 @@ module ActiveSupport
   # context, so only the relevant lines are included.
   #
   # If you need to reconfigure an existing BacktraceCleaner, like the one in Rails, to show as much as possible, you can always
-  # call BacktraceCleaner#remove_silencers!
+  # call BacktraceCleaner#remove_silencers! Also, if you need to reconfigure an existing BacktraceCleaner so that it does not
+  # filter or modify the paths of any lines of the backtrace, you can call BacktraceCleaner#remove_filters! These two methods
+  # will give you a completely untouched backtrace.
   #
   # Example:
   #
@@ -60,6 +62,10 @@ module ActiveSupport
       @silencers = []
     end
 
+    def remove_filters!
+      @filters = []
+    end
+
     private
       def filter(backtrace)
         @filters.each do |f|

data/lib/active_support/cache/mem_cache_store.rb

@@ -64,7 +64,7 @@ module ActiveSupport
           @data.get(key, raw?(options))
         end
       rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
+        logger.error("MemCacheError (#{e}): #{e.message}") if logger
         nil
       end
 
@@ -85,7 +85,7 @@ module ActiveSupport
           response == Response::STORED
         end
       rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
+        logger.error("MemCacheError (#{e}): #{e.message}") if logger
         false
       end
 
@@ -95,7 +95,7 @@ module ActiveSupport
           response == Response::DELETED
         end
       rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
+        logger.error("MemCacheError (#{e}): #{e.message}") if logger
         false
       end
 

data/lib/active_support/cache/strategy/local_cache.rb

@@ -18,7 +18,7 @@ module ActiveSupport
         def middleware
           @middleware ||= begin
             klass = Class.new
-            klass.class_eval(<<-EOS, __FILE__, __LINE__)
+            klass.class_eval(<<-EOS, __FILE__, __LINE__ + 1)
               def initialize(app)
                 @app = app
               end

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/singleton_class'
+require 'active_support/core_ext/kernel/singleton_class'
 
 module ActiveSupport
   # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
@@ -387,7 +387,7 @@ module ActiveSupport
         send("_update_#{symbol}_superclass_callbacks")
         body = send("_#{symbol}_callbacks").compile(nil)
 
-        body, line = <<-RUBY_EVAL, __LINE__
+        body, line = <<-RUBY_EVAL, __LINE__ + 1
           def _run_#{symbol}_callbacks(key = nil, &blk)
             if self.class.send("_update_#{symbol}_superclass_callbacks")
               self.class.__define_runner(#{symbol.inspect})

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

@@ -131,7 +131,7 @@ class Array
     require 'builder' unless defined?(Builder)
 
     options = options.dup
-    options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(first.class.name)) : "records"
+    options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(first.class.name)).tr('/', '_') : "records"
     options[:children] ||= options[:root].singularize
     options[:indent]   ||= 2
     options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])

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

@@ -1,5 +1,4 @@
-require 'active_support/core_ext/object/singleton_class'
-require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/remove_method'
 
 class Class
@@ -41,21 +40,31 @@ class Class
   def class_attribute(*attrs)
     instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]
 
-    s = singleton_class
-    attrs.each do |attr|
-      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
+    attrs.each do |name|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{name}() nil end
+        def self.#{name}?() !!#{name} end
+
+        def self.#{name}=(val)
+          singleton_class.class_eval do
+            remove_possible_method(:#{name})
+            define_method(:#{name}) { val }
+          end
+        end
+
+        def #{name}
+          defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+        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
+        def #{name}?
+          !!#{name}
+        end
+      RUBY
+
+      if instance_writer
+        body = "def #{name}=(value) @#{name} = value end"
+        class_eval body, __FILE__, __LINE__ - 1
+      end
     end
   end
 end

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

@@ -1,6 +1,6 @@
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/object/singleton_class'
+require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/remove_method'
 
 class Class

data/lib/active_support/core_ext/kernel.rb

@@ -2,3 +2,4 @@ require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/agnostics'
 require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/kernel/debugger'
+require 'active_support/core_ext/kernel/singleton_class'

data/lib/active_support/core_ext/{object → kernel}/singleton_class.rb

@@ -1,12 +1,12 @@
-class Object
+module Kernel
   # Returns the object's singleton class.
   def singleton_class
     class << self
       self
     end
-  end unless respond_to?(:singleton_class)
+  end unless respond_to?(:singleton_class) # exists in 1.9.2
 
-  # class_eval on an object acts like singleton_class_eval.
+  # class_eval on an object acts like singleton_class.class_eval.
   def class_eval(*args, &block)
     singleton_class.class_eval(*args, &block)
   end

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

@@ -61,7 +61,7 @@ class Module
   #   e.subject = "Megastars"
   #   e.title    # => "Megastars"
   def alias_attribute(new_name, old_name)
-    module_eval <<-STR, __FILE__, __LINE__+1
+    module_eval <<-STR, __FILE__, __LINE__ + 1
       def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
       def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
       def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end

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

@@ -21,7 +21,7 @@ class Module
   def attr_accessor_with_default(sym, default = nil, &block)
     raise 'Default value or block required' unless !default.nil? || block
     define_method(sym, block_given? ? block : Proc.new { default })
-    module_eval(<<-EVAL, __FILE__, __LINE__)
+    module_eval(<<-EVAL, __FILE__, __LINE__ + 1)
       def #{sym}=(value)                        # def age=(value)
         class << self; attr_reader :#{sym} end  #   class << self; attr_reader :age end
         @#{sym} = value                         #   @age = value

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

@@ -126,7 +126,7 @@ class Module
           %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
         end
 
-      module_eval(<<-EOS, file, line)
+      module_eval(<<-EOS, file, line - 5)
         if instance_methods(false).map(&:to_s).include?("#{prefix}#{method}")
           remove_possible_method("#{prefix}#{method}")
         end

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

@@ -28,7 +28,7 @@ class Module
         raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
       end
 
-      module_eval(<<-EOS, __FILE__, __LINE__)
+      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
           #{with}.synchronize do                                                    #   @@lock.synchronize do
             #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)

data/lib/active_support/core_ext/object.rb

@@ -5,7 +5,6 @@ require 'active_support/core_ext/object/try'
 
 require 'active_support/core_ext/object/conversions'
 require 'active_support/core_ext/object/instance_variables'
-require 'active_support/core_ext/object/singleton_class'
 require 'active_support/core_ext/object/misc'
 require 'active_support/core_ext/object/extending'
 

data/lib/active_support/core_ext/proc.rb

@@ -1,4 +1,4 @@
-require "active_support/core_ext/object"
+require "active_support/core_ext/kernel/singleton_class"
 
 class Proc #:nodoc:
   def bind(object)

data/lib/active_support/core_ext/string/output_safety.rb

@@ -1,5 +1,5 @@
 require 'erb'
-require 'active_support/core_ext/object/singleton_class'
+require 'active_support/core_ext/kernel/singleton_class'
 
 class ERB
   module Util

data/lib/active_support/inflections.rb

@@ -51,6 +51,6 @@ module ActiveSupport
     inflect.irregular('move', 'moves')
     inflect.irregular('cow', 'kine')
 
-    inflect.uncountable(%w(equipment information rice money species series fish sheep))
+    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
   end
 end

data/lib/active_support/inflector/inflections.rb

@@ -148,7 +148,7 @@ module ActiveSupport
     def singularize(word)
       result = word.to_s.dup
 
-      if inflections.uncountables.include?(result.downcase)
+      if inflections.uncountables.any? { |inflection| result =~ /#{inflection}\Z/i }
         result
       else
         inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }

data/lib/active_support/inflector/methods.rb

@@ -36,11 +36,13 @@ module ActiveSupport
     #   "ActiveRecord".underscore         # => "active_record"
     #   "ActiveRecord::Errors".underscore # => active_record/errors
     def underscore(camel_cased_word)
-      camel_cased_word.to_s.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
     end
 
     # Replaces underscores with dashes in the string.

data/lib/active_support/inflector/transliterate.rb

@@ -1,31 +1,47 @@
 # encoding: utf-8
-require 'iconv'
 require 'active_support/core_ext/string/multibyte'
 
 module ActiveSupport
   module Inflector
     extend self
-    
-    # Replaces accented characters with their ascii equivalents.
-    def transliterate(string)
-      Iconv.iconv('ascii//ignore//translit', 'utf-8', string).to_s
-    end
 
-    if RUBY_VERSION >= '1.9'
-      undef_method :transliterate
-      def transliterate(string)
-        proxy = ActiveSupport::Multibyte.proxy_class.new(string)
-        proxy.normalize(:kd).gsub(/[^\x00-\x7F]+/, '')
-      end
+    # UTF-8 byte => ASCII approximate UTF-8 byte(s)
+    ASCII_APPROXIMATIONS = {
+      198 => [65, 69],   # Æ => AE
+      208 => 68,         # Ð => D
+      216 => 79,         # Ø => O
+      222 => [84, 104],  # Þ => Þ
+      223 => [115, 115], # ß => ss
+      230 => [97, 101],  # æ => ae
+      240 => 100,        # ð => d
+      248 => 111,        # ø => o
+      254 => [116, 104], # þ => th
+      272 => 68,         # Đ => D
+      273 => 100,        # đ => đ
+      294 => 72,         # Ħ => H
+      295 => 104,        # ħ => h
+      305 => 105,        # ı => i
+      306 => [73, 74],   # IJ =>IJ
+      307 => [105, 106], # ij => ij
+      312 => 107,        # ĸ => k
+      319 => 76,         # Ŀ => L
+      320 => 108,        # ŀ => l
+      321 => 76,         # Ł => L
+      322 => 108,        # ł => l
+      329 => 110,        # ʼn => n
+      330 => [78, 71],   # Ŋ => NG
+      331 => [110, 103], # ŋ => ng
+      338 => [79, 69],   # Π=> OE
+      339 => [111, 101], # œ => oe
+      358 => 84,         # Ŧ => T
+      359 => 116         # ŧ => t
+    }
 
-    # The iconv transliteration code doesn't function correctly
-    # on some platforms, but it's very fast where it does function.
-    elsif "foo" != (Inflector.transliterate("föö") rescue nil)
-      undef_method :transliterate
-      def transliterate(string)
-        string.mb_chars.normalize(:kd). # Decompose accented characters
-          gsub(/[^\x00-\x7F]+/, '')     # Remove anything non-ASCII entirely (e.g. diacritics).
-      end
+    # Replaces accented characters with an ASCII approximation, or deletes it if none exsits.
+    def transliterate(string)
+      ActiveSupport::Multibyte::Chars.new(string).tidy_bytes.normalize(:d).unpack("U*").map do |char|
+        ASCII_APPROXIMATIONS[char] || (char if char < 128)
+      end.compact.flatten.pack("U*")
     end
 
     # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
@@ -56,6 +72,6 @@ module ActiveSupport
         parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/i, '')
       end
       parameterized_string.downcase
-    end    
+    end
   end
-end
+end

data/lib/active_support/memoizable.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/singleton_class'
+require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/aliasing'
 
 module ActiveSupport

data/lib/active_support/multibyte/chars.rb

@@ -19,7 +19,7 @@ module ActiveSupport #:nodoc:
     #   bad.explicit_checking_method "T".mb_chars.downcase.to_s
     #
     # The default Chars implementation assumes that the encoding of the string is UTF-8, if you want to handle different
-    # encodings you can write your own multibyte string handler and configure it through 
+    # encodings you can write your own multibyte string handler and configure it through
     # ActiveSupport::Multibyte.proxy_class.
     #
     #   class CharsForUTF32
@@ -458,8 +458,10 @@ module ActiveSupport #:nodoc:
       end
 
       # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent resulting in a valid UTF-8 string.
-      def tidy_bytes
-        chars(self.class.tidy_bytes(@wrapped_string))
+      #
+      # Passing +true+ will forcibly tidy all bytes, assuming that the string's encoding is entirely CP1252 or ISO-8859-1.
+      def tidy_bytes(force = false)
+        chars(self.class.tidy_bytes(@wrapped_string, force))
       end
 
       %w(lstrip rstrip strip reverse upcase downcase tidy_bytes capitalize).each do |method|
@@ -528,7 +530,7 @@ module ActiveSupport #:nodoc:
               unpacked << codepoints[marker..pos-1]
               marker = pos
             end
-          end 
+          end
           unpacked
         end
 
@@ -644,33 +646,80 @@ module ActiveSupport #:nodoc:
           codepoints
         end
 
+        def tidy_byte(byte)
+          if byte < 160
+            [UCD.cp1252[byte] || byte].pack("U").unpack("C*")
+          elsif byte < 192
+            [194, byte]
+          else
+            [195, byte - 64]
+          end
+        end
+        private :tidy_byte
+
         # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent resulting in a valid UTF-8 string.
-        def tidy_bytes(string)
-          string.split(//u).map do |c|
-            c.force_encoding(Encoding::ASCII) if c.respond_to?(:force_encoding)
-
-            if !ActiveSupport::Multibyte::VALID_CHARACTER['UTF-8'].match(c)
-              n = c.unpack('C')[0]
-              n < 128 ? n.chr :
-              n < 160 ? [UCD.cp1252[n] || n].pack('U') :
-              n < 192 ? "\xC2" + n.chr : "\xC3" + (n-64).chr
+        #
+        # Passing +true+ will forcibly tidy all bytes, assuming that the string's encoding is entirely CP-1252 or ISO-8859-1.
+        def tidy_bytes(string, force = false)
+          if force
+            return string.unpack("C*").map do |b|
+              tidy_byte(b)
+            end.flatten.compact.pack("C*").unpack("U*").pack("U*")
+          end
+
+          bytes = string.unpack("C*")
+          conts_expected = 0
+          last_lead = 0
+
+          bytes.each_index do |i|
+
+            byte          = bytes[i]
+            is_ascii      = byte < 128
+            is_cont       = byte > 127 && byte < 192
+            is_lead       = byte > 191 && byte < 245
+            is_unused     = byte > 240
+            is_restricted = byte > 244
+
+            # Impossible or highly unlikely byte? Clean it.
+            if is_unused || is_restricted
+              bytes[i] = tidy_byte(byte)
+            elsif is_cont
+              # Not expecting contination byte? Clean up. Otherwise, now expect one less.
+              conts_expected == 0 ? bytes[i] = tidy_byte(byte) : conts_expected -= 1
             else
-              c
+              if conts_expected > 0
+                # Expected continuation, but got ASCII or leading? Clean backwards up to
+                # the leading byte.
+                (1..(i - last_lead)).each {|j| bytes[i - j] = tidy_byte(bytes[i - j])}
+                conts_expected = 0
+              end
+              if is_lead
+                # Final byte is leading? Clean it.
+                if i == bytes.length - 1
+                  bytes[i] = tidy_byte(bytes.last)
+                else
+                  # Valid leading byte? Expect continuations determined by position of
+                  # first zero bit, with max of 3.
+                  conts_expected = byte < 224 ? 1 : byte < 240 ? 2 : 3
+                  last_lead = i
+                end
+              end
             end
-          end.join
+          end
+          bytes.empty? ? "" : bytes.flatten.compact.pack("C*").unpack("U*").pack("U*")
         end
       end
 
       protected
-        
+
         def translate_offset(byte_offset) #:nodoc:
           return nil if byte_offset.nil?
           return 0   if @wrapped_string == ''
-          
+
           if @wrapped_string.respond_to?(:force_encoding)
             @wrapped_string = @wrapped_string.dup.force_encoding(Encoding::ASCII_8BIT)
           end
-          
+
           begin
             @wrapped_string[0...byte_offset].unpack('U*').length
           rescue ArgumentError => e

data/lib/active_support/ordered_hash.rb

@@ -1,13 +1,28 @@
 require 'yaml'
 
+YAML.add_builtin_type("omap") do |type, val|
+  ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
+end
+
 # OrderedHash is namespaced to prevent conflicts with other implementations
 module ActiveSupport
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION >= '1.9'
-    class OrderedHash < ::Hash #:nodoc:
+  class OrderedHash < ::Hash #:nodoc:
+    def to_yaml_type
+      "!tag:yaml.org,2002:omap"
     end
-  else
-    class OrderedHash < Hash #:nodoc:
+
+    def to_yaml(opts = {})
+      YAML.quick_emit(self, opts) do |out|
+        out.seq(taguri, to_yaml_style) do |seq|
+          each do |k, v|
+            seq.add(k => v)
+          end
+        end
+      end
+    end
+
+    # Hash is ordered in Ruby 1.9!
+    if RUBY_VERSION < '1.9'
       def initialize(*args, &block)
         super
         @keys = []
@@ -55,7 +70,7 @@ module ActiveSupport
         end
         super
       end
-      
+
       def delete_if
         super
         sync_keys!
@@ -134,31 +149,10 @@ module ActiveSupport
         "#<OrderedHash #{super}>"
       end
 
-    private
-
-      def sync_keys!
-        @keys.delete_if {|k| !has_key?(k)}
-      end
-    end
-  end
-
-  class OrderedHash #:nodoc:
-    def to_yaml_type
-      "!tag:yaml.org,2002:omap"
-    end
-
-    def to_yaml(opts = {})
-      YAML.quick_emit(self, opts) do |out|
-        out.seq(taguri, to_yaml_style) do |seq|
-          each do |k, v|
-            seq.add(k => v)
-          end
+      private
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
         end
-      end
     end
   end
-
-  YAML.add_builtin_type("omap") do |type, val|
-    ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
-  end
 end

data/lib/active_support/values/time_zone.rb

@@ -194,7 +194,7 @@ module ActiveSupport
     # offset is the number of seconds that this time zone is offset from UTC
     # (GMT). Seconds were chosen as the offset unit because that is the unit that
     # Ruby uses to represent time zone offsets (see Time#utc_offset).
-    def initialize(name, utc_offset, tzinfo = nil)
+    def initialize(name, utc_offset = nil, tzinfo = nil)
       @name = name
       @utc_offset = utc_offset
       @tzinfo = tzinfo
@@ -202,8 +202,12 @@ module ActiveSupport
     end
 
     def utc_offset
-      @current_period ||= tzinfo.current_period
-      @current_period.utc_offset
+      if @utc_offset
+        @utc_offset
+      else
+        @current_period ||= tzinfo.current_period
+        @current_period.utc_offset
+      end
     end
 
     # Returns the offset of this time zone as a formatted string, of the
@@ -305,75 +309,29 @@ module ActiveSupport
       tzinfo.period_for_local(time, dst)
     end
 
-    # TODO: Preload instead of lazy load for thread safety
     def tzinfo
+      @tzinfo ||= TimeZone.find_tzinfo(name)
+    end
+
+    # TODO: Preload instead of lazy load for thread safety
+    def self.find_tzinfo(name)
       require 'tzinfo' unless defined?(::TZInfo)
-      @tzinfo ||= ::TZInfo::Timezone.get(MAPPING[name])
+      ::TZInfo::Timezone.get(MAPPING[name] || name)
+    rescue TZInfo::InvalidTimezoneIdentifier
+      nil
     end
 
     unless const_defined?(:ZONES)
       ZONES = []
       ZONES_MAP = {}
-      [[-39_600, "International Date Line West", "Midway Island", "Samoa" ],
-       [-36_000, "Hawaii" ],
-       [-32_400, "Alaska" ],
-       [-28_800, "Pacific Time (US & Canada)", "Tijuana" ],
-       [-25_200, "Mountain Time (US & Canada)", "Chihuahua", "Mazatlan",
-                 "Arizona" ],
-       [-21_600, "Central Time (US & Canada)", "Saskatchewan", "Guadalajara",
-                 "Mexico City", "Monterrey", "Central America" ],
-       [-18_000, "Eastern Time (US & Canada)", "Indiana (East)", "Bogota",
-                 "Lima", "Quito" ],
-       [-16_200, "Caracas" ],
-       [-14_400, "Atlantic Time (Canada)", "Georgetown", "La Paz", "Santiago" ],
-       [-12_600, "Newfoundland" ],
-       [-10_800, "Brasilia", "Buenos Aires", "Greenland" ],
-       [ -7_200, "Mid-Atlantic" ],
-       [ -3_600, "Azores", "Cape Verde Is." ],
-       [      0, "Dublin", "Edinburgh", "Lisbon", "London", "Casablanca",
-                 "Monrovia", "UTC" ],
-       [  3_600, "Belgrade", "Bratislava", "Budapest", "Ljubljana", "Prague",
-                 "Sarajevo", "Skopje", "Warsaw", "Zagreb", "Brussels",
-                 "Copenhagen", "Madrid", "Paris", "Amsterdam", "Berlin",
-                 "Bern", "Rome", "Stockholm", "Vienna",
-                 "West Central Africa" ],
-       [  7_200, "Bucharest", "Cairo", "Helsinki", "Kyiv", "Riga", "Sofia",
-                 "Tallinn", "Vilnius", "Athens", "Istanbul", "Minsk",
-                 "Jerusalem", "Harare", "Pretoria" ],
-       [ 10_800, "Moscow", "St. Petersburg", "Volgograd", "Kuwait", "Riyadh",
-                 "Nairobi", "Baghdad" ],
-       [ 12_600, "Tehran" ],
-       [ 14_400, "Abu Dhabi", "Muscat", "Baku", "Tbilisi", "Yerevan" ],
-       [ 16_200, "Kabul" ],
-       [ 18_000, "Ekaterinburg", "Islamabad", "Karachi", "Tashkent" ],
-       [ 19_800, "Chennai", "Kolkata", "Mumbai", "New Delhi", "Sri Jayawardenepura" ],
-       [ 20_700, "Kathmandu" ],
-       [ 21_600, "Astana", "Dhaka", "Almaty",
-                 "Novosibirsk" ],
-       [ 23_400, "Rangoon" ],
-       [ 25_200, "Bangkok", "Hanoi", "Jakarta", "Krasnoyarsk" ],
-       [ 28_800, "Beijing", "Chongqing", "Hong Kong", "Urumqi",
-                 "Kuala Lumpur", "Singapore", "Taipei", "Perth", "Irkutsk",
-                 "Ulaan Bataar" ],
-       [ 32_400, "Seoul", "Osaka", "Sapporo", "Tokyo", "Yakutsk" ],
-       [ 34_200, "Darwin", "Adelaide" ],
-       [ 36_000, "Canberra", "Melbourne", "Sydney", "Brisbane", "Hobart",
-                 "Vladivostok", "Guam", "Port Moresby" ],
-       [ 39_600, "Magadan", "Solomon Is.", "New Caledonia" ],
-       [ 43_200, "Fiji", "Kamchatka", "Marshall Is.", "Auckland",
-                 "Wellington" ],
-       [ 46_800, "Nuku'alofa" ]].
-      each do |offset, *places|
-        places.each do |place|
-          place.freeze
-          zone = new(place, offset)
-          ZONES << zone
-          ZONES_MAP[place] = zone
-        end
+      MAPPING.each_key do |place|
+        place.freeze
+        zone = new(place)
+        ZONES << zone
+        ZONES_MAP[place] = zone
       end
       ZONES.sort!
       ZONES.freeze
-      ZONES_MAP.freeze
 
       US_ZONES = ZONES.find_all { |z| z.name =~ /US|Arizona|Indiana|Hawaii|Alaska/ }
       US_ZONES.freeze
@@ -404,7 +362,7 @@ module ActiveSupport
       def [](arg)
         case arg
           when String
-            ZONES_MAP[arg]
+            ZONES_MAP[arg] ||= lookup(arg)
           when Numeric, ActiveSupport::Duration
             arg *= 3600 if arg.abs <= 13
             all.find { |z| z.utc_offset == arg.to_i }
@@ -418,6 +376,12 @@ module ActiveSupport
       def us_zones
         US_ZONES
       end
+
+      private
+
+        def lookup(name)
+          (tzinfo = find_tzinfo(name)) && create(tzinfo.name.freeze)
+        end
     end
   end
 end

data/lib/active_support/version.rb

@@ -3,7 +3,7 @@ module ActiveSupport
     MAJOR = 3
     MINOR = 0
     TINY  = 0
-    BUILD = "beta2"
+    BUILD = "beta3"
 
     STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
   end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 3
   - 0
   - 0
-  - beta2
-  version: 3.0.0.beta2
+  - beta3
+  version: 3.0.0.beta3
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-01 00:00:00 -07:00
+date: 2010-04-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -152,6 +152,7 @@ files:
 - lib/active_support/core_ext/kernel/debugger.rb
 - lib/active_support/core_ext/kernel/reporting.rb
 - lib/active_support/core_ext/kernel/requires.rb
+- lib/active_support/core_ext/kernel/singleton_class.rb
 - lib/active_support/core_ext/kernel.rb
 - lib/active_support/core_ext/load_error.rb
 - lib/active_support/core_ext/logger.rb
@@ -180,7 +181,6 @@ files:
 - lib/active_support/core_ext/object/instance_variables.rb
 - lib/active_support/core_ext/object/misc.rb
 - lib/active_support/core_ext/object/returning.rb
-- lib/active_support/core_ext/object/singleton_class.rb
 - lib/active_support/core_ext/object/to_param.rb
 - lib/active_support/core_ext/object/to_query.rb
 - lib/active_support/core_ext/object/try.rb