activesupport 2.0.5 → 2.1.0

data/lib/active_support/json/encoders/enumerable.rb

@@ -2,8 +2,8 @@ module Enumerable
   # Returns a JSON string representing the enumerable. Any +options+
   # given will be passed on to its elements. For example:
   #
-  # users = User.find(:all)
-  # users.to_json(:only => :name)
+  #   users = User.find(:all)
+  #   # => users.to_json(:only => :name)
   #
   # will pass the <tt>:only => :name</tt> option to each user.
   def to_json(options = {}) #:nodoc:

data/lib/active_support/json/encoders/hash.rb

@@ -5,8 +5,7 @@ class Hash
   # the hash keys. For example:
   #
   #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json
-  #
-  #   {"name": "Konata Izumi", 1: 2, "age": 16}
+  #   # => {"name": "Konata Izumi", 1: 2, "age": 16}
   #
   # The keys in the JSON string are unordered due to the nature of hashes.
   #
@@ -14,12 +13,10 @@ class Hash
   # attributes included, and will accept 1 or more hash keys to include/exclude.
   #
   #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:only => [:name, 'age'])
-  #
-  #   {"name": "Konata Izumi", "age": 16}
+  #   # => {"name": "Konata Izumi", "age": 16}
   #
   #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:except => 1)
-  #
-  #   {"name": "Konata Izumi", "age": 16}
+  #   # => {"name": "Konata Izumi", "age": 16}
   #
   # The +options+ also filter down to any hash values. This is particularly
   # useful for converting hashes containing ActiveRecord objects or any object

data/lib/active_support/json/encoders/object.rb

@@ -1,5 +1,5 @@
 class Object
-  # Dumps object in JSON (JavaScript Object Notation).  See www.json.org for more info.
+  # Dumps object in JSON (JavaScript Object Notation). See www.json.org for more info.
   def to_json(options = {})
     ActiveSupport::JSON.encode(instance_values, options)
   end

data/lib/active_support/json/encoders/string.rb

@@ -1,6 +1,8 @@
 module ActiveSupport
   module JSON
     module Encoding
+      mattr_accessor :escape_regex
+
       ESCAPED_CHARS = {
         "\010" =>  '\b',
         "\f"   =>  '\f',
@@ -17,11 +19,15 @@ module ActiveSupport
   end
 end
 
+ActiveSupport.escape_html_entities_in_json = true
+
 class String
   def to_json(options = nil) #:nodoc:
-    '"' + gsub(/[\010\f\n\r\t"\\><&]/) { |s|
+    json = '"' + gsub(ActiveSupport::JSON::Encoding.escape_regex) { |s|
       ActiveSupport::JSON::Encoding::ESCAPED_CHARS[s]
-    }.gsub(/([\xC0-\xDF][\x80-\xBF]|
+    }
+    json.force_encoding('ascii-8bit') if respond_to?(:force_encoding)
+    json.gsub(/([\xC0-\xDF][\x80-\xBF]|
              [\xE0-\xEF][\x80-\xBF]{2}|
              [\xF0-\xF7][\x80-\xBF]{3})+/nx) { |s|
       s.unpack("U*").pack("n*").unpack("H*")[0].gsub(/.{4}/, '\\\\u\&')

data/lib/active_support/json/encoders/time.rb

@@ -1,5 +1,14 @@
 class Time
-  def to_json(options = nil) #:nodoc:
-    to_datetime.to_json(options)
+  # Returns a JSON string representing the time.
+  #
+  # ==== Example:
+  #   Time.utc(2005,2,1,15,15,10).to_json
+  #   # => 2005/02/01 15:15:10 +0000"
+  def to_json(options = nil)
+    if ActiveSupport.use_standard_json_time_format
+      xmlschema.inspect
+    else
+      %("#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)}")
+    end
   end
 end

data/lib/active_support/json/encoding.rb

@@ -1,5 +1,4 @@
 require 'active_support/json/variable'
-
 require 'active_support/json/encoders/object' # Require explicitly for rdoc.
 Dir["#{File.dirname(__FILE__)}/encoders/**/*.rb"].each do |file|
   basename = File.basename(file, '.rb')

data/lib/active_support/multibyte/chars.rb

@@ -10,7 +10,7 @@ module ActiveSupport::Multibyte #:nodoc:
   # String methods are proxied through the Chars object, and can be accessed through the +chars+ method. Methods
   # which would normally return a String object now return a Chars object so methods can be chained.
   #
-  #   "The Perfect String  ".chars.downcase.strip.normalize #=> "the perfect string"
+  #   "The Perfect String  ".chars.downcase.strip.normalize # => "the perfect string"
   #
   # Chars objects are perfectly interchangeable with String objects as long as no explicit class checks are made.
   # If certain methods do explicitly check the class, call +to_s+ before you pass chars objects to them.
@@ -40,13 +40,15 @@ module ActiveSupport::Multibyte #:nodoc:
       # core dumps. Don't go there.
       @string
     end
-    
+
     # Make duck-typing with String possible
-    def respond_to?(method)
-      super || @string.respond_to?(method) || handler.respond_to?(method) ||
-        (method.to_s =~ /(.*)!/ && handler.respond_to?($1)) || false
+    def respond_to?(method, include_priv = false)
+      super || @string.respond_to?(method, include_priv) ||
+        handler.respond_to?(method, include_priv) ||
+        (method.to_s =~ /(.*)!/ && handler.respond_to?($1, include_priv)) ||
+        false
     end
-    
+
     # Create a new Chars instance.
     def initialize(str)
       @string = str.respond_to?(:string) ? str.string : str

data/lib/active_support/multibyte/handlers/utf8_handler.rb

@@ -147,13 +147,11 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       #
       #   s = "Müller"
       #   s.chars[2] = "e" # Replace character with offset 2
-      #   s
-      #   #=> "Müeler"
+      #   s # => "Müeler"
       #
       #   s = "Müller"
       #   s.chars[1, 2] = "ö" # Replace 2 characters at character offset 1
-      #   s
-      #   #=> "Möler"
+      #   s # => "Möler"
       def []=(str, *args)
         replace_by = args.pop
         # Indexed replace with regular expressions already works
@@ -183,10 +181,10 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       # Example:
       #
       #   "¾ cup".chars.rjust(8).to_s
-      #   #=> "   ¾ cup"
+      #   # => "   ¾ cup"
       #
       #   "¾ cup".chars.rjust(8, " ").to_s # Use non-breaking whitespace
-      #   #=> "   ¾ cup"
+      #   # => "   ¾ cup"
       def rjust(str, integer, padstr=' ')
         justify(str, integer, :right, padstr)
       end
@@ -196,10 +194,10 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       # Example:
       #
       #   "¾ cup".chars.rjust(8).to_s
-      #   #=> "¾ cup   "
+      #   # => "¾ cup   "
       #
       #   "¾ cup".chars.rjust(8, " ").to_s # Use non-breaking whitespace
-      #   #=> "¾ cup   "
+      #   # => "¾ cup   "
       def ljust(str, integer, padstr=' ')
         justify(str, integer, :left, padstr)
       end
@@ -209,10 +207,10 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       # Example:
       #
       #   "¾ cup".chars.center(8).to_s
-      #   #=> " ¾ cup  "
+      #   # => " ¾ cup  "
       #
       #   "¾ cup".chars.center(8, " ").to_s # Use non-breaking whitespace
-      #   #=> " ¾ cup  "
+      #   # => " ¾ cup  "
       def center(str, integer, padstr=' ')
         justify(str, integer, :center, padstr)
       end
@@ -284,7 +282,9 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       # passing strings to databases and validations.
       #
       # * <tt>str</tt> - The string to perform normalization on.
-      # * <tt>form</tt> - The form you want to normalize in. Should be one of the following: :c, :kc, :d or :kd.
+      # * <tt>form</tt> - The form you want to normalize in. Should be one of the following:
+      #   <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>. Default is
+      #   ActiveSupport::Multibyte::DEFAULT_NORMALIZATION_FORM.
       def normalize(str, form=ActiveSupport::Multibyte::DEFAULT_NORMALIZATION_FORM)
         # See http://www.unicode.org/reports/tr15, Table 1
         codepoints = u_unpack(str)

data/lib/active_support/ordered_hash.rb

@@ -0,0 +1,43 @@
+# OrderedHash is namespaced to prevent conflicts with other implementations
+module ActiveSupport
+  # Hash is ordered in Ruby 1.9!
+  if RUBY_VERSION >= '1.9'
+    OrderedHash = ::Hash
+  else
+    class OrderedHash < Array #:nodoc:
+      def []=(key, value)
+        if pair = assoc(key)
+          pair.pop
+          pair << value
+        else
+          self << [key, value]
+        end
+      end
+
+      def [](key)
+        pair = assoc(key)
+        pair ? pair.last : nil
+      end
+
+      def delete(key)
+        pair = assoc(key)
+        pair ? array_index = index(pair) : nil
+        array_index ? delete_at(array_index).last : nil
+      end
+
+      def keys
+        collect { |key, value| key }
+      end
+
+      def values
+        collect { |key, value| value }
+      end
+
+      def to_hash
+        returning({}) do |hash|
+          each { |array| hash[array[0]] = array[1] }
+        end
+      end
+    end
+  end
+end

data/lib/active_support/ordered_options.rb

@@ -1,41 +1,3 @@
-# OrderedHash is namespaced to prevent conflicts with other implementations
-module ActiveSupport
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION >= '1.9'
-    OrderedHash = ::Hash
-  else
-    class OrderedHash < Array #:nodoc:
-      def []=(key, value)
-        if pair = assoc(key)
-          pair.pop
-          pair << value
-        else
-          self << [key, value]
-        end
-      end
-
-      def [](key)
-        pair = assoc(key)
-        pair ? pair.last : nil
-      end
-
-      def keys
-        collect { |key, value| key }
-      end
-
-      def values
-        collect { |key, value| value }
-      end
-
-      def to_hash
-        returning({}) do |hash|
-          each { |array| hash[array[0]] = array[1] }
-        end
-      end
-    end
-  end
-end
-
 class OrderedOptions < ActiveSupport::OrderedHash #:nodoc:
   def []=(key, value)
     super(key.to_sym, value)

data/lib/active_support/test_case.rb

@@ -1,5 +1,13 @@
+require 'test/unit/testcase'
+require 'active_support/testing/setup_and_teardown'
+require 'active_support/testing/default'
+
+# TODO: move to core_ext
+class Test::Unit::TestCase #:nodoc:
+  include ActiveSupport::Testing::SetupAndTeardown
+end
+
 module ActiveSupport
   class TestCase < Test::Unit::TestCase
-    include ActiveSupport::Testing::Default
   end
-end
+end

data/lib/active_support/testing/default.rb

@@ -1,12 +1,9 @@
 module ActiveSupport
   module Testing
-    module Default
-      def run(*args)
-        #method_name appears to be a symbol on 1.8.4 and a string on 1.8.6
-        return if @method_name.to_s == "default_test"
-        super
+    module Default #:nodoc:
+      # Placeholder so test/unit ignores test cases without any tests.
+      def default_test
       end
     end
   end
 end
-

data/lib/active_support/testing/setup_and_teardown.rb

@@ -0,0 +1,93 @@
+module ActiveSupport
+  module Testing
+    module SetupAndTeardown
+      # For compatibility with Ruby < 1.8.6
+      PASSTHROUGH_EXCEPTIONS =
+        if defined?(Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS)
+          Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
+        else
+          [NoMemoryError, SignalException, Interrupt, SystemExit]
+        end
+
+      def self.included(base)
+        base.send :include, ActiveSupport::Callbacks
+        base.define_callbacks :setup, :teardown
+
+        begin
+          require 'mocha'
+          base.alias_method_chain :run, :callbacks_and_mocha
+        rescue LoadError
+          base.alias_method_chain :run, :callbacks
+        end
+      end
+
+      # This redefinition is unfortunate but test/unit shows us no alternative.
+      def run_with_callbacks(result) #:nodoc:
+        return if @method_name.to_s == "default_test"
+
+        yield(Test::Unit::TestCase::STARTED, name)
+        @_result = result
+        begin
+          run_callbacks :setup
+          setup
+          __send__(@method_name)
+        rescue Test::Unit::AssertionFailedError => e
+          add_failure(e.message, e.backtrace)
+        rescue *PASSTHROUGH_EXCEPTIONS
+          raise
+        rescue Exception
+          add_error($!)
+        ensure
+          begin
+            teardown
+            run_callbacks :teardown, :enumerator => :reverse_each
+          rescue Test::Unit::AssertionFailedError => e
+            add_failure(e.message, e.backtrace)
+          rescue *PASSTHROUGH_EXCEPTIONS
+            raise
+          rescue Exception
+            add_error($!)
+          end
+        end
+        result.add_run
+        yield(Test::Unit::TestCase::FINISHED, name)
+      end
+
+      # Doubly unfortunate: mocha does the same so we have to hax their hax.
+      def run_with_callbacks_and_mocha(result)
+        return if @method_name.to_s == "default_test"
+
+        yield(Test::Unit::TestCase::STARTED, name)
+        @_result = result
+        begin
+          mocha_setup
+          begin
+            run_callbacks :setup
+            setup
+            __send__(@method_name)
+            mocha_verify { add_assertion }
+          rescue Mocha::ExpectationError => e
+            add_failure(e.message, e.backtrace)
+          rescue Test::Unit::AssertionFailedError => e
+            add_failure(e.message, e.backtrace)
+          rescue StandardError, ScriptError
+            add_error($!)
+          ensure
+            begin
+              teardown
+              run_callbacks :teardown, :enumerator => :reverse_each
+            rescue Test::Unit::AssertionFailedError => e
+              add_failure(e.message, e.backtrace)
+            rescue StandardError, ScriptError
+              add_error($!)
+            end
+          end
+        ensure
+          mocha_teardown
+        end
+        result.add_run
+        yield(Test::Unit::TestCase::FINISHED, name)
+      end
+    end
+  end
+end

data/lib/active_support/time_with_zone.rb

@@ -0,0 +1,283 @@
+require 'tzinfo'
+module ActiveSupport
+  # 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
+  # +local+, +parse+, +at+ and +now+ on TimeZone instances, and +in_time_zone+ on Time and DateTime instances, for a more
+  # user-friendly syntax. Examples:
+  #
+  #   Time.zone = 'Eastern Time (US & Canada)'        # => 'Eastern Time (US & Canada)'
+  #   Time.zone.local(2007, 2, 10, 15, 30, 45)        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
+  #   Time.zone.parse('2007-02-01 15:30:45')          # => Sat, 10 Feb 2007 15:30:45 EST -05:00
+  #   Time.zone.at(1170361845)                        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
+  #   Time.zone.now                                   # => Sun, 18 May 2008 13:07:55 EDT -04:00
+  #   Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone  # => Sat, 10 Feb 2007 15:30:45 EST -05:00
+  #
+  # See TimeZone and ActiveSupport::CoreExtensions::Time::Zones for further documentation for these methods.
+  #
+  # TimeWithZone instances implement the same API as Ruby Time instances, so that Time and TimeWithZone instances are interchangable. Examples:
+  #
+  #   t = Time.zone.now                     # => Sun, 18 May 2008 13:27:25 EDT -04:00
+  #   t.hour                                # => 13
+  #   t.dst?                                # => true
+  #   t.utc_offset                          # => -14400
+  #   t.zone                                # => "EDT"
+  #   t.to_s(:rfc822)                       # => "Sun, 18 May 2008 13:27:25 -0400"
+  #   t + 1.day                             # => Mon, 19 May 2008 13:27:25 EDT -04:00
+  #   t.beginning_of_year                   # => Tue, 01 Jan 2008 00:00:00 EST -05:00
+  #   t > Time.utc(1999)                    # => true
+  #   t.is_a?(Time)                         # => true
+  #   t.is_a?(ActiveSupport::TimeWithZone)  # => true
+  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)
+    end
+
+    # Returns a Time or DateTime instance that represents the time in UTC.
+    def utc
+      @utc ||= period.to_utc(@time)
+    end
+    alias_method :comparable_time, :utc
+    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)
+    end
+
+    # Returns the simultaneous time in <tt>Time.zone</tt>, or the specified zone.
+    def in_time_zone(new_zone = ::Time.zone)
+      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
+
+    def xmlschema
+      "#{time.strftime("%Y-%m-%dT%H:%M:%S")}#{formatted_offset(true, 'Z')}"
+    end
+    alias_method :iso8601, :xmlschema
+  
+    def to_json(options = nil)
+      if ActiveSupport.use_standard_json_time_format
+        xmlschema.inspect
+      else
+        %("#{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)
+      else
+        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) 
+      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)
+      else
+        "#{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 eql?(other)
+      utc == other
+    end
+    
+    # If wrapped +time+ is a DateTime, use DateTime#since instead of <tt>+</tt>.
+    # Otherwise, just pass on to +method_missing+.
+    def +(other)
+      result = utc.acts_like?(:date) ? utc.since(other) : utc + other rescue utc.since(other)
+      result.in_time_zone(time_zone)
+    end
+    
+    # If a time-like object is passed in, compare it with +utc+.
+    # Else if wrapped +time+ is a DateTime, use DateTime#ago instead of DateTime#-.
+    # Otherwise, just pass on to +method_missing+.
+    def -(other)
+      if other.acts_like?(:time)
+        utc - other
+      else
+        result = utc.acts_like?(:date) ? utc.ago(other) : utc - other rescue utc.ago(other)
+        result.in_time_zone(time_zone)
+      end
+    end
+    
+    def since(other)
+      utc.since(other).in_time_zone(time_zone)
+    end
+    
+    def ago(other)
+      utc.ago(other).in_time_zone(time_zone)
+    end
+    
+    def advance(options)
+      utc.advance(options).in_time_zone(time_zone)
+    end
+    
+    %w(year mon month day mday hour min sec).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    
+    
+    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
+    end
+    alias_method :kind_of?, :is_a?
+  
+    # Neuter freeze because freezing can cause problems with lazy loading of attributes.
+    def freeze
+      self
+    end
+
+    def marshal_dump
+      [utc, time_zone.name, time]
+    end
+    
+    def marshal_load(variables)
+      initialize(variables[0], ::Time.send!(:get_zone, variables[1]), variables[2])
+    end
+
+    # Ensure proxy class responds to all methods that underlying time instance responds to.
+    def respond_to?(sym, include_priv = false)
+      # consistently respond false to acts_like?(:date), regardless of whether #time is a Time or DateTime
+      return false if sym.to_s == 'acts_like_date?'
+      super || time.respond_to?(sym, include_priv)
+    end
+
+    # Send the missing method to +time+ instance, and wrap result in a new TimeWithZone with the existing +time_zone+.
+    def method_missing(sym, *args, &block)
+      result = time.__send__(sym, *args, &block)
+      result.acts_like?(:time) ? self.class.new(nil, time_zone, result) : result
+    end
+    
+    private      
+      def get_period_and_ensure_valid_local_time
+        # 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
+          @time_zone.period_for_local(@time)
+        rescue ::TZInfo::PeriodNotFound
+          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
+          @time += 1.hour
+          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
+  end
+end