Merge branch 'master' into adequaterecord

* master: (311 commits)
  Add a missing changelog entry for #13981 and #14035
  Revert "Fixed plugin_generator test"
  implements new option :month_format_string for date select helpers [Closes #13618]
  add factory methods for empty alias trackers
  guarantee a list in the alias tracker so we can remove a conditional
  stop exposing table_joins
  make most parameters to the AliasTracker required
  make a singleton for AssociationScope
  pass the association and connection to the scope method
  pass the tracker down the stack and construct it in the scope method
  clean up add_constraints signature
  remove the reflection delegate
  remove klass delegator
  remove railties changes. fixes #14054
  remove chain delegate
  remove scope_chain delegate
  Add verb to sanitization note
  fix path shown in mailer's templates
  updated Travis build status image url
  fix guide active_support_core_extensions. add Note to String#indent [ci skip]
  ...

Conflicts:
	activerecord/lib/active_record/associations/join_dependency.rb
	activerecord/test/cases/associations/association_scope_test.rb

33 files changed, 509 insertions, 129 deletions

diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index adaeb99c87..43bfeff079 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,4 +1,90 @@
-*   Added `Hash#compact` and `Hash#compact!` for removing items with nil value from hash.
+*   Fix the implementation of Multibyte::Unicode.tidy_bytes for JRuby
+
+    The existing implementation caused JRuby to raise the error:
+    `Encoding::ConverterNotFoundError: code converter not found (UTF-8 to UTF8-MAC)`
+
+    *Justin Coyne*
+
+*   Fix `to_param` behavior when there are nested empty hashes.
+
+    Before:
+
+        params = {c: 3, d: {}}.to_param # => "&c=3"
+
+    After:
+
+        params = {c: 3, d: {}}.to_param # => "c=3&d="
+
+    Fixes #13892.
+
+    *Hincu Petru*
+
+*   Deprecate custom `BigDecimal` serialization.
+
+    Deprecate the custom `BigDecimal` serialization that is included when requiring
+    `active_support/all` as a fix for #12467. Let Ruby handle YAML serialization
+    for `BigDecimal` instead.
+
+    *David Celis*
+
+*   Fix parsing bugs in `XmlMini`
+
+    Symbols or boolean parsing would raise an error for non string values (e.g.
+    integers). Decimal parsing would fail due to a missing requirement.
+
+    *Birkir A. Barkarson*
+
+*   Maintain the current timezone when calling `wrap_with_time_zone`
+
+    Extend the solution from the fix for #12163 to the general case where `Time`
+    methods are wrapped with a time zone.
+
+    Fixes #12596.
+
+    *Andrew White*
+
+*   Remove behavior that automatically remove the Date/Time stubs, added by `travel`
+    and `travel_to` methods, after each test case.
+
+    Now users have to use the `travel_back` or the block version of `travel` and
+    `travel_to` methods to clean the stubs.
+
+    *Rafael Mendonça França*
+
+*   Add `travel_back` to remove stubs from `travel` and `travel_to`.
+
+    *Rafael Mendonça França*
+
+*   Remove the deprecation about the `#filter` method.
+
+    Filter objects should now rely on method corresponding to the filter type
+    (e.g. `#before`).
+
+    *Aaron Patterson*
+
+*   Add `ActiveSupport::JSON::Encoding.time_precision` as a way to configure the
+    precision of encoded time values:
+
+        Time.utc(2000, 1, 1).as_json                      # => "2000-01-01T00:00:00.000Z"
+        ActiveSupport::JSON::Encoding.time_precision = 0
+        Time.utc(2000, 1, 1).as_json                      # => "2000-01-01T00:00:00Z"
+
+    *Parker Selbert*
+
+*   Maintain the current timezone when calling `change` during DST overlap
+
+    Currently if a time is changed during DST overlap in the autumn then the method
+    `period_for_local` will return the DST period. However if the original time is
+    not DST then this can be surprising and is not what is generally wanted. This
+    commit changes that behavior to maintain the current period if it's in the list
+    of periods returned by `periods_for_local`.
+
+    Fixes #12163.
+
+    *Andrew White*
+
+*   Added `Hash#compact` and `Hash#compact!` for removing items with nil value
+    from hash.
 
     *Celestino Gomes*
 
diff --git a/activesupport/lib/active_support/cache.rb b/activesupport/lib/active_support/cache.rb
index 53154aef27..2b7f5943b5 100644
--- a/activesupport/lib/active_support/cache.rb
+++ b/activesupport/lib/active_support/cache.rb
@@ -452,7 +452,7 @@ module ActiveSupport
       # Clear the entire cache. Be careful with this method since it could
       # affect other processes if shared cache is being used.
       #
-      # Options are passed to the underlying cache implementation.
+      # The options hash is passed to the underlying cache implementation.
       #
       # All implementations may not support this method.
       def clear(options = nil)
diff --git a/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb b/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb
index 39b8cea807..843c592669 100644
--- a/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/big_decimal/conversions.rb
@@ -1,22 +1,7 @@
 require 'bigdecimal'
 require 'bigdecimal/util'
-require 'yaml'
 
 class BigDecimal
-  YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
-
-  def encode_with(coder)
-    string = to_s
-    coder.represent_scalar(nil, YAML_MAPPING[string] || string)
-  end
-
-  # Backport this method if it doesn't exist
-  unless method_defined?(:to_d)
-    def to_d
-      self
-    end
-  end
-
   DEFAULT_STRING_FORMAT = 'F'
   def to_formatted_s(*args)
     if args[0].is_a?(Symbol)
diff --git a/activesupport/lib/active_support/core_ext/big_decimal/yaml_conversions.rb b/activesupport/lib/active_support/core_ext/big_decimal/yaml_conversions.rb
new file mode 100644
index 0000000000..46ba93ead4
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/big_decimal/yaml_conversions.rb
@@ -0,0 +1,14 @@
+ActiveSupport::Deprecation.warn 'core_ext/big_decimal/yaml_conversions is deprecated and will be removed in the future.'
+
+require 'bigdecimal'
+require 'yaml'
+require 'active_support/core_ext/big_decimal/conversions'
+
+class BigDecimal
+  YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
+
+  def encode_with(coder)
+    string = to_s
+    coder.represent_scalar(nil, YAML_MAPPING[string] || string)
+  end
+end
diff --git a/activesupport/lib/active_support/core_ext/enumerable.rb b/activesupport/lib/active_support/core_ext/enumerable.rb
index 4501b7ff58..1343beb87a 100644
--- a/activesupport/lib/active_support/core_ext/enumerable.rb
+++ b/activesupport/lib/active_support/core_ext/enumerable.rb
@@ -35,7 +35,7 @@ module Enumerable
     if block_given?
       Hash[map { |elem| [yield(elem), elem] }]
     else
-      to_enum :index_by
+      to_enum(:index_by) { size if respond_to?(:size) }
     end
   end
 
diff --git a/activesupport/lib/active_support/core_ext/module/attr_internal.rb b/activesupport/lib/active_support/core_ext/module/attr_internal.rb
index db07d549b0..67f0e0335d 100644
--- a/activesupport/lib/active_support/core_ext/module/attr_internal.rb
+++ b/activesupport/lib/active_support/core_ext/module/attr_internal.rb
@@ -27,7 +27,8 @@ class Module
 
     def attr_internal_define(attr_name, type)
       internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, '')
-      class_eval do # class_eval is necessary on 1.9 or else the methods a made private
+      # class_eval is necessary on 1.9 or else the methods are made private
+      class_eval do
         # use native attr_* methods as they are faster on some Ruby implementations
         send("attr_#{type}", internal_name)
       end
diff --git a/activesupport/lib/active_support/core_ext/module/concerning.rb b/activesupport/lib/active_support/core_ext/module/concerning.rb
index b22dc5ff1e..07a392404e 100644
--- a/activesupport/lib/active_support/core_ext/module/concerning.rb
+++ b/activesupport/lib/active_support/core_ext/module/concerning.rb
@@ -63,7 +63,7 @@ class Module
   #
   # == Mix-in noise exiled to its own file:
   #
-  # Once our chunk of behavior starts pushing the scroll-to-understand it
+  # Once our chunk of behavior starts pushing the scroll-to-understand it's
   # boundary, we give in and move it to a separate file. At this size, the
   # overhead feels in good proportion to the size of our extraction, despite
   # diluting our at-a-glance sense of how things really work.
diff --git a/activesupport/lib/active_support/core_ext/object/json.rb b/activesupport/lib/active_support/core_ext/object/json.rb
index 1675145ffe..8e08cfbf26 100644
--- a/activesupport/lib/active_support/core_ext/object/json.rb
+++ b/activesupport/lib/active_support/core_ext/object/json.rb
@@ -16,12 +16,12 @@ require 'active_support/core_ext/module/aliasing'
 # otherwise they will always use to_json gem implementation, which is backwards incompatible in
 # several cases (for instance, the JSON implementation for Hash does not work) with inheritance
 # and consequently classes as ActiveSupport::OrderedHash cannot be serialized to json.
-# 
+#
 # On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
 # JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
 # passes a ::JSON::State object as the only argument to to_json, we can detect that and forward the
 # calls to the original to_json method.
-# 
+#
 # It should be noted that when using ::JSON.{generate,dump} directly, ActiveSupport's encoder is
 # bypassed completely. This means that as_json won't be invoked and the JSON gem will simply
 # ignore any options it does not natively understand. This also means that ::JSON.{generate,dump}
@@ -163,7 +163,7 @@ end
 class Time
   def as_json(options = nil) #:nodoc:
     if ActiveSupport.use_standard_json_time_format
-      xmlschema(3)
+      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
       %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
     end
@@ -183,7 +183,7 @@ end
 class DateTime
   def as_json(options = nil) #:nodoc:
     if ActiveSupport.use_standard_json_time_format
-      xmlschema(3)
+      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
       strftime('%Y/%m/%d %H:%M:%S %z')
     end
diff --git a/activesupport/lib/active_support/core_ext/object/to_param.rb b/activesupport/lib/active_support/core_ext/object/to_param.rb
index 3b137ce6ae..13be0038c2 100644
--- a/activesupport/lib/active_support/core_ext/object/to_param.rb
+++ b/activesupport/lib/active_support/core_ext/object/to_param.rb
@@ -51,8 +51,12 @@ class Hash
   #
   # This method is also aliased as +to_query+.
   def to_param(namespace = nil)
-    collect do |key, value|
-      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-    end.sort! * '&'
+    if empty?
+      namespace ? nil.to_query(namespace) : ''
+    else
+      collect do |key, value|
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end.sort! * '&'
+    end
   end
 end
diff --git a/activesupport/lib/active_support/core_ext/object/to_query.rb b/activesupport/lib/active_support/core_ext/object/to_query.rb
index 5d5fcf00e0..37352fa608 100644
--- a/activesupport/lib/active_support/core_ext/object/to_query.rb
+++ b/activesupport/lib/active_support/core_ext/object/to_query.rb
@@ -18,7 +18,12 @@ class Array
   #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
   def to_query(key)
     prefix = "#{key}[]"
-    collect { |value| value.to_query(prefix) }.join '&'
+
+    if empty?
+      nil.to_query(prefix)
+    else
+      collect { |value| value.to_query(prefix) }.join '&'
+    end
   end
 end
 
diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index 6be19771f5..59675d744e 100644
--- a/activesupport/lib/active_support/dependencies.rb
+++ b/activesupport/lib/active_support/dependencies.rb
@@ -407,7 +407,8 @@ module ActiveSupport #:nodoc:
     end
 
     def load_once_path?(path)
-      # to_s works around a ruby1.9 issue where #starts_with?(Pathname) will always return false
+      # to_s works around a ruby1.9 issue where String#starts_with?(Pathname)
+      # will raise a TypeError: no implicit conversion of Pathname into String
       autoload_once_paths.any? { |base| path.starts_with? base.to_s }
     end
 
@@ -665,6 +666,14 @@ module ActiveSupport #:nodoc:
       constants = normalized.split('::')
       to_remove = constants.pop
 
+      # Remove the file path from the loaded list.
+      file_path = search_for_file(const.underscore)
+      if file_path
+        expanded = File.expand_path(file_path)
+        expanded.sub!(/\.rb\z/, '')
+        self.loaded.delete(expanded)
+      end
+
       if constants.empty?
         parent = Object
       else
diff --git a/activesupport/lib/active_support/inflections.rb b/activesupport/lib/active_support/inflections.rb
index 4ea6abfa12..2ca1124e76 100644
--- a/activesupport/lib/active_support/inflections.rb
+++ b/activesupport/lib/active_support/inflections.rb
@@ -1,5 +1,11 @@
 require 'active_support/inflector/inflections'
 
+#--
+# Defines the standard inflection rules. These are the starting point for
+# new projects and are not considered complete. The current set of inflection
+# rules is frozen. This means, we do not change them to become more complete.
+# This is a safety measure to keep existing applications from breaking.
+#++
 module ActiveSupport
   Inflector.inflections(:en) do |inflect|
     inflect.plural(/$/, 's')
diff --git a/activesupport/lib/active_support/inflector/methods.rb b/activesupport/lib/active_support/inflector/methods.rb
index cdee4c2ca5..b642d87d76 100644
--- a/activesupport/lib/active_support/inflector/methods.rb
+++ b/activesupport/lib/active_support/inflector/methods.rb
@@ -117,7 +117,7 @@ module ActiveSupport
       result.gsub!(/([a-z\d]*)/i) { |match|
         "#{inflections.acronyms[match] || match.downcase}"
       }
-      result.gsub!(/^\w/) { $&.upcase } if options.fetch(:capitalize, true)
+      result.gsub!(/^\w/) { |match| match.upcase } if options.fetch(:capitalize, true)
       result
     end
 
diff --git a/activesupport/lib/active_support/json/encoding.rb b/activesupport/lib/active_support/json/encoding.rb
index 2859075e10..f29d42276d 100644
--- a/activesupport/lib/active_support/json/encoding.rb
+++ b/activesupport/lib/active_support/json/encoding.rb
@@ -4,6 +4,7 @@ require 'active_support/core_ext/module/delegation'
 module ActiveSupport
   class << self
     delegate :use_standard_json_time_format, :use_standard_json_time_format=,
+      :time_precision, :time_precision=,
       :escape_html_entities_in_json, :escape_html_entities_in_json=,
       :encode_big_decimal_as_string, :encode_big_decimal_as_string=,
       :json_encoder, :json_encoder=,
@@ -60,7 +61,7 @@ module ActiveSupport
           end
 
           # Mark these as private so we don't leak encoding-specific constructs
-          private_constant :ESCAPED_CHARS, :ESCAPE_REGEX_WITH_HTML_ENTITIES, 
+          private_constant :ESCAPED_CHARS, :ESCAPE_REGEX_WITH_HTML_ENTITIES,
             :ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, :EscapedString
 
           # Convert an object into a "JSON-ready" representation composed of
@@ -105,6 +106,10 @@ module ActiveSupport
         # as a safety measure.
         attr_accessor :escape_html_entities_in_json
 
+        # Sets the precision of encoded time values.
+        # Defaults to 3 (equivalent to millisecond precision)
+        attr_accessor :time_precision
+
         # Sets the encoder used by Rails to encode Ruby objects into JSON strings
         # in +Object#to_json+ and +ActiveSupport::JSON.encode+.
         attr_accessor :json_encoder
@@ -161,6 +166,7 @@ module ActiveSupport
       self.use_standard_json_time_format = true
       self.escape_html_entities_in_json  = true
       self.json_encoder = JSONGemEncoder
+      self.time_precision = 3
     end
   end
 end
diff --git a/activesupport/lib/active_support/key_generator.rb b/activesupport/lib/active_support/key_generator.rb
index 598c46bce5..51d2da3a79 100644
--- a/activesupport/lib/active_support/key_generator.rb
+++ b/activesupport/lib/active_support/key_generator.rb
@@ -57,18 +57,16 @@ module ActiveSupport
     # secret they've provided is at least 30 characters in length.
     def ensure_secret_secure(secret)
       if secret.blank?
-        raise ArgumentError, "A secret is required to generate an " +
-          "integrity hash for cookie session data. Use " +
-          "config.secret_key_base = \"some secret phrase of at " +
-          "least #{SECRET_MIN_LENGTH} characters\"" +
-          "in config/initializers/secret_token.rb"
+        raise ArgumentError, "A secret is required to generate an integrity hash " \
+          "for cookie session data. Set a secret_key_base of at least " \
+          "#{SECRET_MIN_LENGTH} characters in config/secrets.yml."
       end
 
       if secret.length < SECRET_MIN_LENGTH
-        raise ArgumentError, "Secret should be something secure, " +
-          "like \"#{SecureRandom.hex(16)}\". The value you " +
-          "provided, \"#{secret}\", is shorter than the minimum length " +
-          "of #{SECRET_MIN_LENGTH} characters"
+        raise ArgumentError, "Secret should be something secure, " \
+          "like \"#{SecureRandom.hex(16)}\". The value you " \
+          "provided, \"#{secret}\", is shorter than the minimum length " \
+          "of #{SECRET_MIN_LENGTH} characters."
       end
     end
   end
diff --git a/activesupport/lib/active_support/message_encryptor.rb b/activesupport/lib/active_support/message_encryptor.rb
index 7773611e11..b019ad0dec 100644
--- a/activesupport/lib/active_support/message_encryptor.rb
+++ b/activesupport/lib/active_support/message_encryptor.rb
@@ -12,7 +12,7 @@ module ActiveSupport
   # This can be used in situations similar to the <tt>MessageVerifier</tt>, but
   # where you don't want users to be able to determine the value of the payload.
   #
-  #   salt  = SecureRandom.random_bytes(64) 
+  #   salt  = SecureRandom.random_bytes(64)
   #   key   = ActiveSupport::KeyGenerator.new('password').generate_key(salt) # => "\x89\xE0\x156\xAC..."
   #   crypt = ActiveSupport::MessageEncryptor.new(key)                       # => #<ActiveSupport::MessageEncryptor ...>
   #   encrypted_data = crypt.encrypt_and_sign('my secret data')              # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
diff --git a/activesupport/lib/active_support/multibyte/unicode.rb b/activesupport/lib/active_support/multibyte/unicode.rb
index 84799c2399..ea3cdcd024 100644
--- a/activesupport/lib/active_support/multibyte/unicode.rb
+++ b/activesupport/lib/active_support/multibyte/unicode.rb
@@ -213,7 +213,7 @@ module ActiveSupport
       end
 
       # Ruby >= 2.1 has String#scrub, which is faster than the workaround used for < 2.1.
-      if RUBY_VERSION >= '2.1'
+      if '<3'.respond_to?(:scrub)
         # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
         # resulting in a valid UTF-8 string.
         #
@@ -233,16 +233,16 @@ module ActiveSupport
           # We're going to 'transcode' bytes from UTF-8 when possible, then fall back to
           # CP1252 when we get errors. The final string will be 'converted' back to UTF-8
           # before returning.
-          reader = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_8_MAC)
+          reader = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_16LE)
 
           source = string.dup
-          out = ''.force_encoding(Encoding::UTF_8_MAC)
+          out = ''.force_encoding(Encoding::UTF_16LE)
 
           loop do
             reader.primitive_convert(source, out)
             _, _, _, error_bytes, _ = reader.primitive_errinfo
             break if error_bytes.nil?
-            out << error_bytes.encode(Encoding::UTF_8_MAC, Encoding::Windows_1252, invalid: :replace, undef: :replace)
+            out << error_bytes.encode(Encoding::UTF_16LE, Encoding::Windows_1252, invalid: :replace, undef: :replace)
           end
 
           reader.finish
diff --git a/activesupport/lib/active_support/testing/isolation.rb b/activesupport/lib/active_support/testing/isolation.rb
index 75ead48376..908af176be 100644
--- a/activesupport/lib/active_support/testing/isolation.rb
+++ b/activesupport/lib/active_support/testing/isolation.rb
@@ -37,6 +37,8 @@ module ActiveSupport
       module Forking
         def run_in_isolation(&blk)
           read, write = IO.pipe
+          read.binmode
+          write.binmode
 
           pid = fork do
             read.close
diff --git a/activesupport/lib/active_support/testing/time_helpers.rb b/activesupport/lib/active_support/testing/time_helpers.rb
index 94230e56ba..9e0a3d6345 100644
--- a/activesupport/lib/active_support/testing/time_helpers.rb
+++ b/activesupport/lib/active_support/testing/time_helpers.rb
@@ -1,10 +1,48 @@
 module ActiveSupport
   module Testing
+    class SimpleStubs # :nodoc:
+      Stub = Struct.new(:object, :method_name, :original_method)
+
+      def initialize
+        @stubs = {}
+      end
+
+      def stub_object(object, method_name, return_value)
+        key = [object.object_id, method_name]
+
+        if (stub = @stubs[key])
+          unstub_object(stub)
+        end
+
+        new_name = "__simple_stub__#{method_name}"
+
+        @stubs[key] = Stub.new(object, method_name, new_name)
+
+        object.singleton_class.send :alias_method, new_name, method_name
+        object.define_singleton_method(method_name) { return_value }
+      end
+
+      def unstub_all!
+        @stubs.each_value do |stub|
+          unstub_object(stub)
+        end
+        @stubs = {}
+      end
+
+      private
+
+        def unstub_object(stub)
+          singleton_class = stub.object.singleton_class
+          singleton_class.send :undef_method, stub.method_name
+          singleton_class.send :alias_method, stub.method_name, stub.original_method
+          singleton_class.send :undef_method, stub.original_method
+        end
+    end
+
     # Containing helpers that helps you test passage of time.
     module TimeHelpers
-      # Change current time to the time in the future or in the past by a given time difference by
-      # stubbing +Time.now+ and +Date.today+. Note that the stubs are automatically removed
-      # at the end of each test.
+      # Changes current time to the time in the future or in the past by a given time difference by
+      # stubbing +Time.now+ and +Date.today+.
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       #   travel 1.day
@@ -23,9 +61,8 @@ module ActiveSupport
         travel_to Time.now + duration, &block
       end
 
-      # Change current time to the given time by stubbing +Time.now+ and +Date.today+ to return the
-      # time or date passed into this method. Note that the stubs are automatically removed
-      # at the end of each test.
+      # Changes current time to the given time by stubbing +Time.now+ and +Date.today+ to return the
+      # time or date passed into this method.
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       #   travel_to Time.new(2004, 11, 24, 01, 04, 44)
@@ -37,19 +74,36 @@ module ActiveSupport
       #
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       #   travel_to Time.new(2004, 11, 24, 01, 04, 44) do
-      #     User.create.created_at # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #     Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
       #   end
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       def travel_to(date_or_time, &block)
-        Time.stubs now: date_or_time.to_time
-        Date.stubs today: date_or_time.to_date
+        simple_stubs.stub_object(Time, :now, date_or_time.to_time)
+        simple_stubs.stub_object(Date, :today, date_or_time.to_date)
 
         if block_given?
           block.call
-          Time.unstub :now
-          Date.unstub :today
+          travel_back
         end
       end
+
+      # Returns the current time back to its original state, by removing the stubs added by
+      # `travel` and `travel_to`.
+      #
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      #   travel_to Time.new(2004, 11, 24, 01, 04, 44)
+      #   Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
+      #   travel_back
+      #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
+      def travel_back
+        simple_stubs.unstub_all!
+      end
+
+      private
+
+        def simple_stubs
+          @simple_stubs ||= SimpleStubs.new
+        end
     end
   end
 end
diff --git a/activesupport/lib/active_support/time_with_zone.rb b/activesupport/lib/active_support/time_with_zone.rb
index 50db7da9d9..c25c97cfa8 100644
--- a/activesupport/lib/active_support/time_with_zone.rb
+++ b/activesupport/lib/active_support/time_with_zone.rb
@@ -45,7 +45,7 @@ module ActiveSupport
 
     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
+      @period = @utc ? period : get_period_and_ensure_valid_local_time(period)
     end
 
     # Returns a Time or DateTime instance that represents the time in +time_zone+.
@@ -132,8 +132,8 @@ module ActiveSupport
     end
 
     def xmlschema(fraction_digits = 0)
-      fraction = if fraction_digits > 0
-        (".%06i" % time.usec)[0, fraction_digits + 1]
+      fraction = if fraction_digits.to_i > 0
+        (".%06i" % time.usec)[0, fraction_digits.to_i + 1]
       end
 
       "#{time.strftime("%Y-%m-%dT%H:%M:%S")}#{fraction}#{formatted_offset(true, 'Z')}"
@@ -154,7 +154,7 @@ module ActiveSupport
     #   # => "2005/02/01 05:15:10 -1000"
     def as_json(options = nil)
       if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-        xmlschema(3)
+        xmlschema(ActiveSupport::JSON::Encoding.time_precision)
       else
         %(#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
       end
@@ -367,12 +367,12 @@ module ActiveSupport
     end
 
     private
-      def get_period_and_ensure_valid_local_time
+      def get_period_and_ensure_valid_local_time(period)
         # 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)
+          period || @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
@@ -390,7 +390,8 @@ module ActiveSupport
 
       def wrap_with_time_zone(time)
         if time.acts_like?(:time)
-          self.class.new(nil, time_zone, time)
+          periods = time_zone.periods_for_local(time)
+          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
         elsif time.is_a?(Range)
           wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
         else
diff --git a/activesupport/lib/active_support/values/time_zone.rb b/activesupport/lib/active_support/values/time_zone.rb
index beaac42fa1..eb785d46ce 100644
--- a/activesupport/lib/active_support/values/time_zone.rb
+++ b/activesupport/lib/active_support/values/time_zone.rb
@@ -352,6 +352,10 @@ module ActiveSupport
       tzinfo.period_for_local(time, dst)
     end
 
+    def periods_for_local(time) #:nodoc:
+      tzinfo.periods_for_local(time)
+    end
+
     def self.find_tzinfo(name)
       TZInfo::TimezoneProxy.new(MAPPING[name] || name)
     end
diff --git a/activesupport/lib/active_support/xml_mini.rb b/activesupport/lib/active_support/xml_mini.rb
index d082a0a499..009ee4db90 100644
--- a/activesupport/lib/active_support/xml_mini.rb
+++ b/activesupport/lib/active_support/xml_mini.rb
@@ -1,7 +1,9 @@
 require 'time'
 require 'base64'
+require 'bigdecimal'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/date_time/calculations'
 
 module ActiveSupport
   # = XmlMini
@@ -56,13 +58,13 @@ module ActiveSupport
     # TODO use regexp instead of Date.parse
     unless defined?(PARSING)
       PARSING = {
-        "symbol"       => Proc.new { |symbol|  symbol.to_sym },
+        "symbol"       => Proc.new { |symbol|  symbol.to_s.to_sym },
         "date"         => Proc.new { |date|    ::Date.parse(date) },
         "datetime"     => Proc.new { |time|    Time.xmlschema(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) },
+        "boolean"      => Proc.new { |boolean| %w(1 true).include?(boolean.to_s.strip) },
         "string"       => Proc.new { |string|  string.to_s },
         "yaml"         => Proc.new { |yaml|    YAML::load(yaml) rescue yaml },
         "base64Binary" => Proc.new { |bin|     ::Base64.decode64(bin) },
diff --git a/activesupport/test/core_ext/big_decimal/yaml_conversions_test.rb b/activesupport/test/core_ext/big_decimal/yaml_conversions_test.rb
new file mode 100644
index 0000000000..e634679d20
--- /dev/null
+++ b/activesupport/test/core_ext/big_decimal/yaml_conversions_test.rb
@@ -0,0 +1,11 @@
+require 'abstract_unit'
+
+class BigDecimalYamlConversionsTest < ActiveSupport::TestCase
+  def test_to_yaml
+    assert_deprecated { require 'active_support/core_ext/big_decimal/yaml_conversions' }
+    assert_match("--- 100000.30020320320000000000000000000000000000001\n", BigDecimal.new('100000.30020320320000000000000000000000000000001').to_yaml)
+    assert_match("--- .Inf\n",  BigDecimal.new('Infinity').to_yaml)
+    assert_match("--- .NaN\n",  BigDecimal.new('NaN').to_yaml)
+    assert_match("--- -.Inf\n", BigDecimal.new('-Infinity').to_yaml)
+  end
+end
diff --git a/activesupport/test/core_ext/bigdecimal_test.rb b/activesupport/test/core_ext/bigdecimal_test.rb
index b386e55d6c..423a3f2e9d 100644
--- a/activesupport/test/core_ext/bigdecimal_test.rb
+++ b/activesupport/test/core_ext/bigdecimal_test.rb
@@ -2,18 +2,6 @@ require 'abstract_unit'
 require 'active_support/core_ext/big_decimal'
 
 class BigDecimalTest < ActiveSupport::TestCase
-  def test_to_yaml
-    assert_match("--- 100000.30020320320000000000000000000000000000001\n", BigDecimal.new('100000.30020320320000000000000000000000000000001').to_yaml)
-    assert_match("--- .Inf\n",  BigDecimal.new('Infinity').to_yaml)
-    assert_match("--- .NaN\n",  BigDecimal.new('NaN').to_yaml)
-    assert_match("--- -.Inf\n", BigDecimal.new('-Infinity').to_yaml)
-  end
-
-  def test_to_d
-    bd = BigDecimal.new '10'
-    assert_equal bd, bd.to_d
-  end
-  
   def test_to_s
     bd = BigDecimal.new '0.01'
     assert_equal '0.01', bd.to_s
diff --git a/activesupport/test/core_ext/enumerable_test.rb b/activesupport/test/core_ext/enumerable_test.rb
index 6781e3c20e..6fcf6e8743 100644
--- a/activesupport/test/core_ext/enumerable_test.rb
+++ b/activesupport/test/core_ext/enumerable_test.rb
@@ -8,7 +8,6 @@ class SummablePayment < Payment
 end
 
 class EnumerableTests < ActiveSupport::TestCase
-  Enumerator = [].each.class
 
   class GenericEnumerable
     include Enumerable
@@ -21,26 +20,6 @@ class EnumerableTests < ActiveSupport::TestCase
     end
   end
 
-  def test_group_by
-    names = %w(marcel sam david jeremy)
-    klass = Struct.new(:name)
-    objects = (1..50).map do
-      klass.new names.sample
-    end
-
-    enum = GenericEnumerable.new(objects)
-    grouped = enum.group_by { |object| object.name }
-
-    grouped.each do |name, group|
-      assert group.all? { |person| person.name == name }
-    end
-
-    assert_equal objects.uniq.map(&:name), grouped.keys
-    assert({}.merge(grouped), "Could not convert ActiveSupport::OrderedHash into Hash")
-    assert_equal Enumerator, enum.group_by.class
-    assert_equal grouped, enum.group_by.each(&:name)
-  end
-
   def test_sums
     enum = GenericEnumerable.new([5, 15, 10])
     assert_equal 30, enum.sum
@@ -94,6 +73,10 @@ class EnumerableTests < ActiveSupport::TestCase
     assert_equal({ 5 => Payment.new(5), 15 => Payment.new(15), 10 => Payment.new(10) },
                  payments.index_by { |p| p.price })
     assert_equal Enumerator, payments.index_by.class
+    if Enumerator.method_defined? :size
+      assert_equal nil, payments.index_by.size
+      assert_equal 42, (1..42).index_by.size
+    end
     assert_equal({ 5 => Payment.new(5), 15 => Payment.new(15), 10 => Payment.new(10) },
                  payments.index_by.each { |p| p.price })
   end
diff --git a/activesupport/test/core_ext/object/to_query_test.rb b/activesupport/test/core_ext/object/to_query_test.rb
index 92f996f9a4..f887a9e613 100644
--- a/activesupport/test/core_ext/object/to_query_test.rb
+++ b/activesupport/test/core_ext/object/to_query_test.rb
@@ -46,6 +46,19 @@ class ToQueryTest < ActiveSupport::TestCase
       :person => {:id => [20, 10]}
   end
 
+  def test_nested_empty_hash
+    assert_equal '',
+      {}.to_query
+    assert_query_equal 'a=1&b%5Bc%5D=3&b%5Bd%5D=',
+      { a: 1, b: { c: 3, d: {} } }
+    assert_query_equal 'b%5Bc%5D=false&b%5Be%5D=&b%5Bf%5D=&p=12',
+      { p: 12, b: { c: false, e: nil, f: '' } }
+    assert_query_equal 'b%5Bc%5D=3&b%5Bf%5D=&b%5Bk%5D=',
+      { b: { c: 3, k: {}, f: '' } }
+    assert_query_equal 'a%5B%5D=&b=3',
+      {a: [], b: 3}
+  end
+
   private
     def assert_query_equal(expected, actual)
       assert_equal expected.split('&'), actual.to_query.split('&')
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index d4f8ba8cdd..072b970a2d 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -161,6 +161,10 @@ class StringInflectionsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_humanize_with_html_escape
+    assert_equal 'Hello', ERB::Util.html_escape("hello").humanize
+  end
+
   def test_ord
     assert_equal 97, 'a'.ord
     assert_equal 97, 'abc'.ord
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index 5494824a40..7fe4d4a6b2 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -1,6 +1,5 @@
 require 'abstract_unit'
 require 'active_support/time'
-require 'active_support/json'
 
 class TimeWithZoneTest < ActiveSupport::TestCase
 
@@ -66,25 +65,6 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal 'EDT', ActiveSupport::TimeWithZone.new(Time.utc(2000, 6), @time_zone).zone #dst
   end
 
-  def test_to_json_with_use_standard_json_time_format_config_set_to_false
-    old, ActiveSupport.use_standard_json_time_format = ActiveSupport.use_standard_json_time_format, false
-    assert_equal "\"1999/12/31 19:00:00 -0500\"", ActiveSupport::JSON.encode(@twz)
-  ensure
-    ActiveSupport.use_standard_json_time_format = old
-  end
-
-  def test_to_json_with_use_standard_json_time_format_config_set_to_true
-    old, ActiveSupport.use_standard_json_time_format = ActiveSupport.use_standard_json_time_format, true
-    assert_equal "\"1999-12-31T19:00:00.000-05:00\"", ActiveSupport::JSON.encode(@twz)
-  ensure
-    ActiveSupport.use_standard_json_time_format = old
-  end
-
-  def test_to_json_when_wrapping_a_date_time
-    twz = ActiveSupport::TimeWithZone.new(DateTime.civil(2000), @time_zone)
-    assert_equal '"1999-12-31T19:00:00.000-05:00"', ActiveSupport::JSON.encode(twz)
-  end
-
   def test_nsec
     local     = Time.local(2011,6,7,23,59,59,Rational(999999999, 1000))
     with_zone = ActiveSupport::TimeWithZone.new(nil, ActiveSupport::TimeZone["Hawaii"], local)
@@ -131,6 +111,10 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal "1999-12-31T19:00:00.001234-05:00", @twz.xmlschema(12)
   end
 
+  def test_xmlschema_with_nil_fractional_seconds
+    assert_equal "1999-12-31T19:00:00-05:00", @twz.xmlschema(nil)
+  end
+
   def test_to_yaml
     assert_match(/^--- 2000-01-01 00:00:00(\.0+)?\s*Z\n/, @twz.to_yaml)
   end
@@ -511,6 +495,16 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_equal "Fri, 31 Dec 1999 19:00:30 EST -05:00", @twz.change(:sec => 30).inspect
   end
 
+  def test_change_at_dst_boundary
+    twz = ActiveSupport::TimeWithZone.new(Time.at(1319936400).getutc, ActiveSupport::TimeZone['Madrid'])
+    assert_equal twz, twz.change(:min => 0)
+  end
+
+  def test_round_at_dst_boundary
+    twz = ActiveSupport::TimeWithZone.new(Time.at(1319936400).getutc, ActiveSupport::TimeZone['Madrid'])
+    assert_equal twz, twz.round
+  end
+
   def test_advance
     assert_equal "Fri, 31 Dec 1999 19:00:00 EST -05:00", @twz.inspect
     assert_equal "Mon, 31 Dec 2001 19:00:00 EST -05:00", @twz.advance(:years => 2).inspect
diff --git a/activesupport/test/dependencies_test.rb b/activesupport/test/dependencies_test.rb
index 00bec5bd9d..4ca63b3417 100644
--- a/activesupport/test/dependencies_test.rb
+++ b/activesupport/test/dependencies_test.rb
@@ -948,6 +948,18 @@ class DependenciesTest < ActiveSupport::TestCase
     Object.class_eval { remove_const :A if const_defined?(:A) }
   end
 
+  def test_access_unloaded_constants_for_reload
+    with_autoloading_fixtures do
+      assert_kind_of Module, A
+      assert_kind_of Class, A::B # Necessary to load A::B for the test
+      ActiveSupport::Dependencies.mark_for_unload(A::B)
+      ActiveSupport::Dependencies.remove_unloadable_constants!
+       
+      A::B # Make sure no circular dependency error
+    end
+  end
+
+
   def test_autoload_once_paths_should_behave_when_recursively_loading
     with_loading 'dependencies', 'autoloading_fixtures' do
       ActiveSupport::Dependencies.autoload_once_paths = [ActiveSupport::Dependencies.autoload_paths.last]
diff --git a/activesupport/test/json/encoding_test.rb b/activesupport/test/json/encoding_test.rb
index 78cf4819f9..c4283ee79a 100644
--- a/activesupport/test/json/encoding_test.rb
+++ b/activesupport/test/json/encoding_test.rb
@@ -3,6 +3,7 @@ require 'securerandom'
 require 'abstract_unit'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/json'
+require 'active_support/time'
 
 class TestJSONEncoding < ActiveSupport::TestCase
   class Foo
@@ -226,21 +227,17 @@ class TestJSONEncoding < ActiveSupport::TestCase
   end
 
   def test_time_to_json_includes_local_offset
-    prev = ActiveSupport.use_standard_json_time_format
-    ActiveSupport.use_standard_json_time_format = true
-    with_env_tz 'US/Eastern' do
-      assert_equal %("2005-02-01T15:15:10.000-05:00"), ActiveSupport::JSON.encode(Time.local(2005,2,1,15,15,10))
+    with_standard_json_time_format(true) do
+      with_env_tz 'US/Eastern' do
+        assert_equal %("2005-02-01T15:15:10.000-05:00"), ActiveSupport::JSON.encode(Time.local(2005,2,1,15,15,10))
+      end
     end
-  ensure
-    ActiveSupport.use_standard_json_time_format = prev
   end
 
   def test_hash_with_time_to_json
-    prev = ActiveSupport.use_standard_json_time_format
-    ActiveSupport.use_standard_json_time_format = false
-    assert_equal '{"time":"2009/01/01 00:00:00 +0000"}', { :time => Time.utc(2009) }.to_json
-  ensure
-    ActiveSupport.use_standard_json_time_format = prev
+    with_standard_json_time_format(false) do
+      assert_equal '{"time":"2009/01/01 00:00:00 +0000"}', { :time => Time.utc(2009) }.to_json
+    end
   end
 
   def test_nested_hash_with_float
@@ -453,6 +450,57 @@ EXPECTED
     assert_nil h.as_json_called
   end
 
+  def test_twz_to_json_with_use_standard_json_time_format_config_set_to_false
+    with_standard_json_time_format(false) do
+      zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
+      time = ActiveSupport::TimeWithZone.new(Time.utc(2000), zone)
+      assert_equal "\"1999/12/31 19:00:00 -0500\"", ActiveSupport::JSON.encode(time)
+    end
+  end
+
+  def test_twz_to_json_with_use_standard_json_time_format_config_set_to_true
+    with_standard_json_time_format(true) do
+      zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
+      time = ActiveSupport::TimeWithZone.new(Time.utc(2000), zone)
+      assert_equal "\"1999-12-31T19:00:00.000-05:00\"", ActiveSupport::JSON.encode(time)
+    end
+  end
+
+  def test_twz_to_json_with_custom_time_precision
+    with_standard_json_time_format(true) do
+      ActiveSupport::JSON::Encoding.time_precision = 0
+      zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
+      time = ActiveSupport::TimeWithZone.new(Time.utc(2000), zone)
+      assert_equal "\"1999-12-31T19:00:00-05:00\"", ActiveSupport::JSON.encode(time)
+    end
+  ensure
+    ActiveSupport::JSON::Encoding.time_precision = 3
+  end
+
+  def test_time_to_json_with_custom_time_precision
+    with_standard_json_time_format(true) do
+      ActiveSupport::JSON::Encoding.time_precision = 0
+      assert_equal "\"2000-01-01T00:00:00Z\"", ActiveSupport::JSON.encode(Time.utc(2000))
+    end
+  ensure
+    ActiveSupport::JSON::Encoding.time_precision = 3
+  end
+
+  def test_datetime_to_json_with_custom_time_precision
+    with_standard_json_time_format(true) do
+      ActiveSupport::JSON::Encoding.time_precision = 0
+      assert_equal "\"2000-01-01T00:00:00+00:00\"", ActiveSupport::JSON.encode(DateTime.new(2000))
+    end
+  ensure
+    ActiveSupport::JSON::Encoding.time_precision = 3
+  end
+
+  def test_twz_to_json_when_wrapping_a_date_time
+    zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
+    time = ActiveSupport::TimeWithZone.new(DateTime.new(2000), zone)
+    assert_equal '"1999-12-31T19:00:00.000-05:00"', ActiveSupport::JSON.encode(time)
+  end
+
   protected
 
     def object_keys(json_object)
@@ -465,4 +513,11 @@ EXPECTED
     ensure
       old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
     end
+
+    def with_standard_json_time_format(boolean = true)
+      old, ActiveSupport.use_standard_json_time_format = ActiveSupport.use_standard_json_time_format, boolean
+      yield
+    ensure
+      ActiveSupport.use_standard_json_time_format = old
+    end
 end
diff --git a/activesupport/test/test_test.rb b/activesupport/test/test_test.rb
index 8a71ef4324..0fa08c0e3a 100644
--- a/activesupport/test/test_test.rb
+++ b/activesupport/test/test_test.rb
@@ -162,6 +162,10 @@ class TimeHelperTest < ActiveSupport::TestCase
     Time.stubs now: Time.now
   end
 
+  teardown do
+    travel_back
+  end
+
   def test_time_helper_travel
     expected_time = Time.now + 1.day
     travel 1.day
@@ -201,4 +205,16 @@ class TimeHelperTest < ActiveSupport::TestCase
     assert_not_equal expected_time, Time.now
     assert_not_equal Date.new(2004, 11, 24), Date.today
   end
+
+  def test_time_helper_travel_back
+    expected_time = Time.new(2004, 11, 24, 01, 04, 44)
+
+    travel_to expected_time
+    assert_equal expected_time, Time.now
+    assert_equal Date.new(2004, 11, 24), Date.today
+    travel_back
+
+    assert_not_equal expected_time, Time.now
+    assert_not_equal Date.new(2004, 11, 24), Date.today
+  end
 end
diff --git a/activesupport/test/time_zone_test.rb b/activesupport/test/time_zone_test.rb
index 1107b48460..cd79efbe8c 100644
--- a/activesupport/test/time_zone_test.rb
+++ b/activesupport/test/time_zone_test.rb
@@ -97,6 +97,7 @@ class TimeZoneTest < ActiveSupport::TestCase
     assert_equal Date.new(2000, 1, 1), ActiveSupport::TimeZone['Eastern Time (US & Canada)'].today
     travel_to(Time.utc(2000, 1, 2, 5)) # midnight Jan 2 EST
     assert_equal Date.new(2000, 1, 2), ActiveSupport::TimeZone['Eastern Time (US & Canada)'].today
+    travel_back
   end
 
   def test_tomorrow
@@ -108,6 +109,7 @@ class TimeZoneTest < ActiveSupport::TestCase
     assert_equal Date.new(2000, 1, 2), ActiveSupport::TimeZone['Eastern Time (US & Canada)'].tomorrow
     travel_to(Time.utc(2000, 1, 2, 5)) # midnight Jan 2 EST
     assert_equal Date.new(2000, 1, 3), ActiveSupport::TimeZone['Eastern Time (US & Canada)'].tomorrow
+    travel_back
   end
 
   def test_yesterday
@@ -119,6 +121,7 @@ class TimeZoneTest < ActiveSupport::TestCase
     assert_equal Date.new(1999, 12, 31), ActiveSupport::TimeZone['Eastern Time (US & Canada)'].yesterday
     travel_to(Time.utc(2000, 1, 2, 5)) # midnight Jan 2 EST
     assert_equal Date.new(2000, 1, 1), ActiveSupport::TimeZone['Eastern Time (US & Canada)'].yesterday
+    travel_back
   end
 
   def test_local
diff --git a/activesupport/test/xml_mini_test.rb b/activesupport/test/xml_mini_test.rb
index d992028323..753effb54e 100644
--- a/activesupport/test/xml_mini_test.rb
+++ b/activesupport/test/xml_mini_test.rb
@@ -169,4 +169,128 @@ module XmlMiniTest
       end
     end
   end
+
+  class ParsingTest < ActiveSupport::TestCase
+    def setup
+      @parsing = ActiveSupport::XmlMini::PARSING
+    end
+
+    def test_symbol
+      parser = @parsing['symbol']
+      assert_equal :symbol, parser.call('symbol')
+      assert_equal :symbol, parser.call(:symbol)
+      assert_equal :'123', parser.call(123)
+      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+    end
+
+    def test_date
+      parser = @parsing['date']
+      assert_equal Date.new(2013,11,12), parser.call("2013-11-12T0211Z")
+      assert_raises(TypeError) { parser.call(1384190018) }
+      assert_raises(ArgumentError) { parser.call("not really a date") }
+    end
+
+    def test_datetime
+      parser = @parsing['datetime']
+      assert_equal Time.new(2013,11,12,02,11,00,0), parser.call("2013-11-12T02:11:00Z")
+      assert_equal DateTime.new(2013,11,12), parser.call("2013-11-12T0211Z")
+      assert_equal DateTime.new(2013,11,12,02,11), parser.call("2013-11-12T02:11Z")
+      assert_equal DateTime.new(2013,11,12,02,11), parser.call("2013-11-12T11:11+9")
+      assert_raises(ArgumentError) { parser.call("1384190018") }
+    end
+
+    def test_integer
+      parser = @parsing['integer']
+      assert_equal 123, parser.call(123)
+      assert_equal 123, parser.call(123.003)
+      assert_equal 123, parser.call("123")
+      assert_equal 0, parser.call("")
+      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+    end
+
+    def test_float
+      parser = @parsing['float']
+      assert_equal 123, parser.call("123")
+      assert_equal 123.003, parser.call("123.003")
+      assert_equal 123.0, parser.call("123,003")
+      assert_equal 0.0, parser.call("")
+      assert_equal 123, parser.call(123)
+      assert_equal 123.05, parser.call(123.05)
+      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+    end
+
+    def test_decimal
+      parser = @parsing['decimal']
+      assert_equal 123, parser.call("123")
+      assert_equal 123.003, parser.call("123.003")
+      assert_equal 123.0, parser.call("123,003")
+      assert_equal 0.0, parser.call("")
+      assert_equal 123, parser.call(123)
+      assert_raises(ArgumentError) { parser.call(123.04) }
+      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+    end
+
+    def test_boolean
+      parser = @parsing['boolean']
+      [1, true, "1"].each do |value|
+        assert parser.call(value)
+      end
+
+      [0, false, "0"].each do |value|
+        assert_not parser.call(value)
+      end
+    end
+
+    def test_string
+      parser = @parsing['string']
+      assert_equal "123", parser.call(123)
+      assert_equal "123", parser.call("123")
+      assert_equal "[]", parser.call("[]")
+      assert_equal "[]", parser.call([])
+      assert_equal "{}", parser.call({})
+      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+    end
+
+    def test_yaml
+      yaml = <<YAML
+product:
+  - sku         : BL394D
+    quantity    : 4
+    description : Basketball
+YAML
+      expected = {
+        "product"=> [
+          {"sku"=>"BL394D", "quantity"=>4, "description"=>"Basketball"}
+        ]
+      }
+      parser = @parsing['yaml']
+      assert_equal(expected, parser.call(yaml))
+      assert_equal({1 => 'test'}, parser.call({1 => 'test'}))
+      assert_equal({"1 => 'test'"=>nil}, parser.call("{1 => 'test'}"))
+    end
+
+    def test_base64Binary_and_binary
+      base64 = <<BASE64
+TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
+IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
+dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
+dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo
+ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=
+BASE64
+      expected_base64 = <<EXPECTED
+Man is distinguished, not only by his reason, but by this singular passion from
+other animals, which is a lust of the mind, that by a perseverance of delight
+in the continued and indefatigable generation of knowledge, exceeds the short
+vehemence of any carnal pleasure.
+EXPECTED
+
+      parser = @parsing['base64Binary']
+      assert_equal expected_base64.gsub(/\n/," ").strip, parser.call(base64)
+      parser.call("NON BASE64 INPUT")
+
+      parser = @parsing['binary']
+      assert_equal expected_base64.gsub(/\n/," ").strip, parser.call(base64, 'encoding' => 'base64')
+      assert_equal "IGNORED INPUT", parser.call("IGNORED INPUT", {})
+    end
+  end
 end