activesupport 5.1.0.beta1 → 5.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b24faa7a716ac5041f15e7d350045c0d924f3d2f
-  data.tar.gz: '062183011cca6201592cac435ae85aa7c17d4125'
+  metadata.gz: cdb51a155bf19eb4c458b9e685b69ee9dc14955f
+  data.tar.gz: 6e55441daa607f1a1fe428013ad6c4f2dbae9add
 SHA512:
-  metadata.gz: 11e55fb810a57d7661ac3b426e5b720a814ba276e93221d4dbc2b35676e3006a58d8ea74b0ecd1603d83e1b520abf27a157ea3a17aa6eb955fdd5ed3d3bce1c0
-  data.tar.gz: f4cf5759de9351d52827c9070581ea463295d62e83bd345c91dc81b8db4605efb4264dcbad8f88f0e8c8d6b5a3b5952120be6f4bfcc814f22cf1a25884e706b4
+  metadata.gz: bc85b3606636ab5930381604d3475a69eadb3df97dca0f8b41f32fe383573e522ccac3d993930946af27649c1a272258db7726c3b7467bbd38af43ff3834a8b5
+  data.tar.gz: f67b616745e51658bb4144c1cb4c38f402f7341b2ecbb7a7fdf0e3dfb74244f0566c321b77c8e74ba5904d5474527616cc03cbd2b29551998d24d3d8464b4b4e

data/CHANGELOG.md

@@ -1,10 +1,227 @@
+## Rails 5.1.0.rc1 (March 20, 2017) ##
+
+*   Fixed bug in `DateAndTime::Compatibility#to_time` that caused it to
+    raise `RuntimeError: can't modify frozen Time` when called on any frozen `Time`.
+    Properly pass through the frozen `Time` or `ActiveSupport::TimeWithZone` object
+    when calling `#to_time`.
+
+    *Kevin McPhillips* & *Andrew White*
+
+*   Remove implicit coercion deprecation of durations
+
+    In #28204 we deprecated implicit conversion of durations to a numeric which
+    represented the number of seconds in the duration because of unwanted side
+    effects with calculations on durations and dates. This unfortunately had
+    the side effect of forcing a explicit cast when configuring third-party
+    libraries like expiration in Redis, e.g:
+
+        redis.expire("foo", 5.minutes)
+
+    To work around this we've removed the deprecation and added a private class
+    that wraps the numeric and can perform calculation involving durations and
+    ensure that they remain a duration irrespective of the order of operations.
+
+    *Andrew White*
+
+*   Update `titleize` regex to allow apostrophes
+
+    In 4b685aa the regex in `titleize` was updated to not match apostrophes to
+    better reflect the nature of the transformation. Unfortunately, this had the
+    side effect of breaking capitalization on the first word of a sub-string, e.g:
+
+        >> "This was 'fake news'".titleize
+        => "This Was 'fake News'"
+
+    This is fixed by extending the look-behind to also check for a word
+    character on the other side of the apostrophe.
+
+    Fixes #28312.
+
+    *Andrew White*
+
+*   Add `rfc3339` aliases to `xmlschema` for `Time` and `ActiveSupport::TimeWithZone`
+
+    For naming consistency when using the RFC 3339 profile of ISO 8601 in applications.
+
+    *Andrew White*
+
+*   Add `Time.rfc3339` parsing method
+
+    `Time.xmlschema` and consequently its alias `iso8601` accepts timestamps
+    without a offset in contravention of the RFC 3339 standard. This method
+    enforces that constraint and raises an `ArgumentError` if it doesn't.
+
+    *Andrew White*
+
+*   Add `ActiveSupport::TimeZone.rfc3339` parsing method
+
+    Previously, there was no way to get a RFC 3339 timestamp into a specific
+    timezone without either using `parse` or chaining methods. The new method
+    allows parsing directly into the timezone, e.g:
+
+        >> Time.zone = "Hawaii"
+        => "Hawaii"
+        >> Time.zone.rfc3339("1999-12-31T14:00:00Z")
+        => Fri, 31 Dec 1999 14:00:00 HST -10:00
+
+    This new method has stricter semantics than the current `parse` method,
+    and will raise an `ArgumentError` instead of returning nil, e.g:
+
+        >> Time.zone = "Hawaii"
+        => "Hawaii"
+        >> Time.zone.rfc3339("foobar")
+        ArgumentError: invalid date
+        >> Time.zone.parse("foobar")
+        => nil
+
+    It will also raise an `ArgumentError` when either the time or offset
+    components are missing, e.g:
+
+        >> Time.zone = "Hawaii"
+        => "Hawaii"
+        >> Time.zone.rfc3339("1999-12-31")
+        ArgumentError: invalid date
+        >> Time.zone.rfc3339("1999-12-31T14:00:00")
+        ArgumentError: invalid date
+
+    *Andrew White*
+
+*   Add `ActiveSupport::TimeZone.iso8601` parsing method
+
+    Previously, there was no way to get a ISO 8601 timestamp into a specific
+    timezone without either using `parse` or chaining methods. The new method
+    allows parsing directly into the timezone, e.g:
+
+        >> Time.zone = "Hawaii"
+        => "Hawaii"
+        >> Time.zone.iso8601("1999-12-31T14:00:00Z")
+        => Fri, 31 Dec 1999 14:00:00 HST -10:00
+
+    If the timestamp is a ISO 8601 date (YYYY-MM-DD), then the time is set
+    to midnight, e.g:
+
+        >> Time.zone = "Hawaii"
+        => "Hawaii"
+        >> Time.zone.iso8601("1999-12-31")
+        => Fri, 31 Dec 1999 00:00:00 HST -10:00
+
+    This new method has stricter semantics than the current `parse` method,
+    and will raise an `ArgumentError` instead of returning nil, e.g:
+
+        >> Time.zone = "Hawaii"
+        => "Hawaii"
+        >> Time.zone.iso8601("foobar")
+        ArgumentError: invalid date
+        >> Time.zone.parse("foobar")
+        => nil
+
+    *Andrew White*
+
+*   Deprecate implicit coercion of `ActiveSupport::Duration`
+
+    Currently `ActiveSupport::Duration` implicitly converts to a seconds
+    value when used in a calculation except for the explicit examples of
+    addition and subtraction where the duration is the receiver, e.g:
+
+        >> 2 * 1.day
+        => 172800
+
+    This results in lots of confusion especially when using durations
+    with dates because adding/subtracting a value from a date treats
+    integers as a day and not a second, e.g:
+
+        >> Date.today
+        => Wed, 01 Mar 2017
+        >> Date.today + 2 * 1.day
+        => Mon, 10 Apr 2490
+
+    To fix this we're implementing `coerce` so that we can provide a
+    deprecation warning with the intent of removing the implicit coercion
+    in Rails 5.2, e.g:
+
+        >> 2 * 1.day
+        DEPRECATION WARNING: Implicit coercion of ActiveSupport::Duration
+        to a Numeric is deprecated and will raise a TypeError in Rails 5.2.
+        => 172800
+
+    In Rails 5.2 it will raise `TypeError`, e.g:
+
+        >> 2 * 1.day
+        TypeError: ActiveSupport::Duration can't be coerced into Integer
+
+    This is the same behavior as with other types in Ruby, e.g:
+
+        >> 2 * "foo"
+        TypeError: String can't be coerced into Integer
+        >> "foo" * 2
+        => "foofoo"
+
+    As part of this deprecation add `*` and `/` methods to `AS::Duration`
+    so that calculations that keep the duration as the receiver work
+    correctly whether the final receiver is a `Date` or `Time`, e.g:
+
+        >> Date.today
+        => Wed, 01 Mar 2017
+        >> Date.today + 1.day * 2
+        => Fri, 03 Mar 2017
+
+    Fixes #27457.
+
+    *Andrew White*
+
+*   Update `DateTime#change` to support `:usec` and `:nsec` options.
+
+    Adding support for these options now allows us to update the `DateTime#end_of`
+    methods to match the equivalent `Time#end_of` methods, e.g:
+
+        datetime = DateTime.now.end_of_day
+        datetime.nsec == 999999999 # => true
+
+    Fixes #21424.
+
+    *Dan Moore*, *Andrew White*
+
+*   Add `ActiveSupport::Duration#before` and `#after` as aliases for `#until` and `#since`
+
+    These read more like English and require less mental gymnastics to read and write.
+
+    Before:
+
+        2.weeks.since(customer_start_date)
+        5.days.until(today)
+
+    After:
+
+        2.weeks.after(customer_start_date)
+        5.days.before(today)
+
+    *Nick Johnstone*
+
+*   Soft-deprecated the top-level `HashWithIndifferentAccess` constant.
+    `ActiveSupport::HashWithIndifferentAccess` should be used instead.
+
+    Fixes #28157.
+
+    *Robin Dupret*
+
+*   In Core Extensions, make `MarshalWithAutoloading#load` pass through the second, optional
+    argument for `Marshal#load( source [, proc] )`. This way we don't have to do
+    `Marshal.method(:load).super_method.call(source, proc)` just to be able to pass a proc.
+
+    *Jeff Latz*
+
+*   `ActiveSupport::Gzip.decompress` now checks checksum and length in footer.
+
+    *Dylan Thacker-Smith*
+
+
 ## Rails 5.1.0.beta1 (February 23, 2017) ##
 
 *   Cache `ActiveSupport::TimeWithZone#to_datetime` before freezing.
 
     *Adam Rice*
 
-*   Deprecate `.halt_callback_chains_on_return_false`.
+*   Deprecate `ActiveSupport.halt_callback_chains_on_return_false`.
 
     *Rafael Mendonça França*
 
@@ -67,10 +284,10 @@
     duration's numeric value isn't used in calculations, only parts are used.
 
     Methods on `Numeric` like `2.days` now use these predefined durations
-    to avoid duplicating of duration constants through the codebase and
+    to avoid duplication of duration constants through the codebase and
     eliminate creation of intermediate durations.
 
-    *Andrey Novikov, Andrew White*
+    *Andrey Novikov*, *Andrew White*
 
 *   Change return value of `Rational#duplicable?`, `ComplexClass#duplicable?`
     to false.
@@ -309,28 +526,28 @@
     *John Gesimondo*
 
 *   `travel/travel_to` travel time helpers, now raise on nested calls,
-     as this can lead to confusing time stubbing.
+    as this can lead to confusing time stubbing.
 
-     Instead of:
+    Instead of:
 
-         travel_to 2.days.from_now do
-           # 2 days from today
-           travel_to 3.days.from_now do
-             # 5 days from today
-           end
-         end
+        travel_to 2.days.from_now do
+          # 2 days from today
+          travel_to 3.days.from_now do
+            # 5 days from today
+          end
+        end
 
-     preferred way to achieve above is:
+    preferred way to achieve above is:
 
-         travel 2.days do
-           # 2 days from today
-         end
+        travel 2.days do
+          # 2 days from today
+        end
 
-         travel 5.days do
-           # 5 days from today
-         end
+        travel 5.days do
+          # 5 days from today
+        end
 
-     *Vipul A M*
+    *Vipul A M*
 
 *   Support parsing JSON time in ISO8601 local time strings in
     `ActiveSupport::JSON.decode` when `parse_json_times` is enabled.

data/lib/active_support/cache/memory_store.rb

@@ -28,6 +28,7 @@ module ActiveSupport
         @pruning = false
       end
 
+      # Delete all data stored in a given cache store.
       def clear(options = nil)
         synchronize do
           @data.clear
@@ -83,6 +84,7 @@ module ActiveSupport
         modify_value(name, -amount, options)
       end
 
+      # Deletes cache entries if the cache key matches a given pattern.
       def delete_matched(matcher, options = nil)
         options = merged_options(options)
         instrument(:delete_matched, matcher.inspect) do

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

@@ -28,13 +28,13 @@ module ActiveSupport
             response[2] = ::Rack::BodyProxy.new(response[2]) do
               LocalCacheRegistry.set_cache_for(local_cache_key, nil)
             end
+            cleanup_on_body_close = true
             response
           rescue Rack::Utils::InvalidParameterError
-            LocalCacheRegistry.set_cache_for(local_cache_key, nil)
             [400, {}, []]
-          rescue Exception
-            LocalCacheRegistry.set_cache_for(local_cache_key, nil)
-            raise
+          ensure
+            LocalCacheRegistry.set_cache_for(local_cache_key, nil) unless
+              cleanup_on_body_close
           end
         end
       end

data/lib/active_support/core_ext/date_and_time/compatibility.rb

@@ -10,13 +10,5 @@ module DateAndTime
     # this behavior, but new apps will have an initializer that sets
     # this to true, because the new behavior is preferred.
     mattr_accessor(:preserve_timezone, instance_writer: false) { false }
-
-    def to_time
-      if preserve_timezone
-        @_to_time_with_instance_offset ||= getlocal(utc_offset)
-      else
-        @_to_time_with_system_offset ||= getlocal
-      end
-    end
   end
 end

data/lib/active_support/core_ext/date_time/calculations.rb

@@ -47,13 +47,23 @@ class DateTime
   #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => DateTime.new(1981, 8, 1, 22, 35, 0)
   #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => DateTime.new(1981, 8, 29, 0, 0, 0)
   def change(options)
+    if new_nsec = options[:nsec]
+      raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
+      new_fraction = Rational(new_nsec, 1000000000)
+    else
+      new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+      new_fraction = Rational(new_usec, 1000000)
+    end
+
+    raise ArgumentError, "argument out of range" if new_fraction >= 1
+
     ::DateTime.civil(
       options.fetch(:year, year),
       options.fetch(:month, month),
       options.fetch(:day, day),
       options.fetch(:hour, hour),
       options.fetch(:min, options[:hour] ? 0 : min),
-      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec + sec_fraction),
+      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec) + new_fraction,
       options.fetch(:offset, offset),
       options.fetch(:start, start)
     )
@@ -122,7 +132,7 @@ class DateTime
 
   # Returns a new DateTime representing the end of the day (23:59:59).
   def end_of_day
-    change(hour: 23, min: 59, sec: 59)
+    change(hour: 23, min: 59, sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_day :end_of_day
 
@@ -134,7 +144,7 @@ class DateTime
 
   # Returns a new DateTime representing the end of the hour (hh:59:59).
   def end_of_hour
-    change(min: 59, sec: 59)
+    change(min: 59, sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_hour :end_of_hour
 
@@ -146,7 +156,7 @@ class DateTime
 
   # Returns a new DateTime representing the end of the minute (hh:mm:59).
   def end_of_minute
-    change(sec: 59)
+    change(sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_minute :end_of_minute
 

data/lib/active_support/core_ext/date_time/compatibility.rb

@@ -1,5 +1,15 @@
 require "active_support/core_ext/date_and_time/compatibility"
 
 class DateTime
-  prepend DateAndTime::Compatibility
+  include DateAndTime::Compatibility
+
+  remove_possible_method :to_time
+
+  # Either return an instance of `Time` with the same UTC offset
+  # as +self+ or an instance of `Time` representing the same time
+  # in the the local system timezone depending on the setting of
+  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
+  def to_time
+    preserve_timezone ? getlocal(utc_offset) : getlocal
+  end
 end

data/lib/active_support/core_ext/marshal.rb

@@ -1,7 +1,7 @@
 module ActiveSupport
   module MarshalWithAutoloading # :nodoc:
-    def load(source)
-      super(source)
+    def load(source, proc = nil)
+      super(source, proc)
     rescue ArgumentError, NameError => exc
       if exc.message.match(%r|undefined class/module (.+?)(?:::)?\z|)
         # try loading the class/module

data/lib/active_support/core_ext/object/with_options.rb

@@ -62,6 +62,17 @@ class Object
   #
   # Hence the inherited default for `if` key is ignored.
   #
+  # NOTE: You cannot call class methods implicitly inside of with_options.
+  # You can access these methods using the class name instead:
+  #
+  #   class Phone < ActiveRecord::Base
+  #     enum phone_number_type: [home: 0, office: 1, mobile: 2]
+  #
+  #     with_options presence: true do
+  #       validates :phone_number_type, inclusion: { in: Phone.phone_number_types.keys }
+  #     end
+  #   end
+  #
   def with_options(options, &block)
     option_merger = ActiveSupport::OptionMerger.new(self, options)
     block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)

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

@@ -53,6 +53,29 @@ class Time
     end
     alias_method :at_without_coercion, :at
     alias_method :at, :at_with_coercion
+
+    # Creates a +Time+ instance from an RFC 3339 string.
+    #
+    #   Time.rfc3339('1999-12-31T14:00:00-10:00') # => 2000-01-01 00:00:00 -1000
+    #
+    # If the time or offset components are missing then an +ArgumentError+ will be raised.
+    #
+    #   Time.rfc3339('1999-12-31') # => ArgumentError: invalid date
+    def rfc3339(str)
+      parts = Date._rfc3339(str)
+
+      raise ArgumentError, "invalid date" if parts.empty?
+
+      Time.new(
+        parts.fetch(:year),
+        parts.fetch(:mon),
+        parts.fetch(:mday),
+        parts.fetch(:hour),
+        parts.fetch(:min),
+        parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
+        parts.fetch(:offset)
+      )
+    end
   end
 
   # Returns the number of seconds since 00:00:00.

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

@@ -1,5 +1,14 @@
 require "active_support/core_ext/date_and_time/compatibility"
+require "active_support/core_ext/module/remove_method"
 
 class Time
-  prepend DateAndTime::Compatibility
+  include DateAndTime::Compatibility
+
+  remove_possible_method :to_time
+
+  # Either return +self+ or the time in the local system timezone depending
+  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
+  def to_time
+    preserve_timezone ? self : getlocal
+  end
 end

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

@@ -64,4 +64,7 @@ class Time
   def formatted_offset(colon = true, alternate_utc_string = nil)
     utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
   end
+
+  # Aliased to +xmlschema+ for compatibility with +DateTime+
+  alias_method :rfc3339, :xmlschema
 end

data/lib/active_support/duration.rb

@@ -1,5 +1,8 @@
 require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/acts_like"
+require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
 
 module ActiveSupport
   # Provides accurate date and time measurements using Date#advance and
@@ -7,6 +10,66 @@ module ActiveSupport
   #
   #   1.month.ago       # equivalent to Time.now.advance(months: -1)
   class Duration
+    class Scalar < Numeric #:nodoc:
+      attr_reader :value
+      delegate :to_i, :to_f, :to_s, to: :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def coerce(other)
+        [Scalar.new(other), self]
+      end
+
+      def -@
+        Scalar.new(-value)
+      end
+
+      def <=>(other)
+        if Scalar === other || Duration === other
+          value <=> other.value
+        elsif Numeric === other
+          value <=> other
+        else
+          nil
+        end
+      end
+
+      def +(other)
+        calculate(:+, other)
+      end
+
+      def -(other)
+        calculate(:-, other)
+      end
+
+      def *(other)
+        calculate(:*, other)
+      end
+
+      def /(other)
+        calculate(:/, other)
+      end
+
+      private
+        def calculate(op, other)
+          if Scalar === other
+            Scalar.new(value.public_send(op, other.value))
+          elsif Duration === other
+            Duration.seconds(value).public_send(op, other)
+          elsif Numeric === other
+            Scalar.new(value.public_send(op, other))
+          else
+            raise_type_error(other)
+          end
+        end
+
+        def raise_type_error(other)
+          raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
+        end
+    end
+
     SECONDS_PER_MINUTE = 60
     SECONDS_PER_HOUR   = 3600
     SECONDS_PER_DAY    = 86400
@@ -88,6 +151,24 @@ module ActiveSupport
       @parts.default = 0
     end
 
+    def coerce(other) #:nodoc:
+      if Scalar === other
+        [other, self]
+      else
+        [Scalar.new(other), self]
+      end
+    end
+
+    # Compares one Duration with another or a Numeric to this Duration.
+    # Numeric values are treated as seconds.
+    def <=>(other)
+      if Duration === other
+        value <=> other.value
+      elsif Numeric === other
+        value <=> other
+      end
+    end
+
     # Adds another Duration or a Numeric to this Duration. Numeric values
     # are treated as seconds.
     def +(other)
@@ -109,6 +190,28 @@ module ActiveSupport
       self + (-other)
     end
 
+    # Multiplies this Duration by a Numeric and returns a new Duration.
+    def *(other)
+      if Scalar === other || Duration === other
+        Duration.new(value * other.value, parts.map { |type, number| [type, number * other.value] })
+      elsif Numeric === other
+        Duration.new(value * other, parts.map { |type, number| [type, number * other] })
+      else
+        raise_type_error(other)
+      end
+    end
+
+    # Divides this Duration by a Numeric and returns a new Duration.
+    def /(other)
+      if Scalar === other || Duration === other
+        Duration.new(value / other.value, parts.map { |type, number| [type, number / other.value] })
+      elsif Numeric === other
+        Duration.new(value / other, parts.map { |type, number| [type, number / other] })
+      else
+        raise_type_error(other)
+      end
+    end
+
     def -@ #:nodoc:
       Duration.new(-value, parts.map { |type, number| [type, -number] })
     end
@@ -180,6 +283,7 @@ module ActiveSupport
       sum(1, time)
     end
     alias :from_now :since
+    alias :after :since
 
     # Calculates a new Time or Date that is as far in the past
     # as this Duration represents.
@@ -187,6 +291,7 @@ module ActiveSupport
       sum(-1, time)
     end
     alias :until :ago
+    alias :before :ago
 
     def inspect #:nodoc:
       parts.
@@ -210,8 +315,6 @@ module ActiveSupport
       ISO8601Serializer.new(self, precision: precision).serialize
     end
 
-    delegate :<=>, to: :value
-
     private
 
       def sum(sign, time = ::Time.current)
@@ -235,5 +338,9 @@ module ActiveSupport
       def method_missing(method, *args, &block)
         value.send(method, *args, &block)
       end
+
+      def raise_type_error(other)
+        raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
+      end
   end
 end

data/lib/active_support/gem_version.rb

@@ -8,7 +8,7 @@ module ActiveSupport
     MAJOR = 5
     MINOR = 1
     TINY  = 0
-    PRE   = "beta1"
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/gzip.rb

@@ -21,7 +21,7 @@ module ActiveSupport
 
     # Decompresses a gzipped string.
     def self.decompress(source)
-      Zlib::GzipReader.new(StringIO.new(source)).read
+      Zlib::GzipReader.wrap(StringIO.new(source), &:read)
     end
 
     # Compresses a string using gzip.

data/lib/active_support/hash_with_indifferent_access.rb

@@ -270,7 +270,7 @@ module ActiveSupport
     end
 
     def compact
-      dup.compact!
+      dup.tap(&:compact!)
     end
 
     # Convert to a regular hash with string keys.
@@ -316,4 +316,6 @@ module ActiveSupport
   end
 end
 
+# :stopdoc:
+
 HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

data/lib/active_support/inflector/methods.rb

@@ -161,7 +161,7 @@ module ActiveSupport
     #   titleize('TheManWithoutAPast')       # => "The Man Without A Past"
     #   titleize('raiders_of_the_lost_ark')  # => "Raiders Of The Lost Ark"
     def titleize(word)
-      humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { |match| match.capitalize }
+      humanize(underscore(word)).gsub(/\b(?<!\w['’`])[a-z]/) { |match| match.capitalize }
     end
 
     # Creates the name of a table like Rails does for models to table names.

data/lib/active_support/message_encryptor.rb

@@ -50,6 +50,11 @@ module ActiveSupport
     # key by using <tt>ActiveSupport::KeyGenerator</tt> or a similar key
     # derivation function.
     #
+    # First additional parameter is used as the signature key for +MessageVerifier+.
+    # This allows you to specify keys to encrypt and sign data.
+    #
+    #    ActiveSupport::MessageEncryptor.new('secret', 'signature_secret')
+    #
     # Options:
     # * <tt>:cipher</tt>     - Cipher to use. Can be any cipher returned by
     #   <tt>OpenSSL::Cipher.ciphers</tt>. Default is 'aes-256-cbc'.
@@ -61,7 +66,7 @@ module ActiveSupport
       sign_secret = signature_key_or_options.first
       @secret = secret
       @sign_secret = sign_secret
-      @cipher = options[:cipher] || "aes-256-cbc"
+      @cipher = options[:cipher] || DEFAULT_CIPHER
       @digest = options[:digest] || "SHA1" unless aead_mode?
       @verifier = resolve_verifier
       @serializer = options[:serializer] || Marshal

data/lib/active_support/time_with_zone.rb

@@ -148,6 +148,7 @@ module ActiveSupport
       "#{time.strftime(PRECISIONS[fraction_digits.to_i])}#{formatted_offset(true, 'Z'.freeze)}"
     end
     alias_method :iso8601, :xmlschema
+    alias_method :rfc3339, :xmlschema
 
     # Coerces time to a string for JSON encoding. The default format is ISO 8601.
     # You can get %Y/%m/%d %H:%M:%S +offset style by setting
@@ -410,6 +411,17 @@ module ActiveSupport
       @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
     end
 
+    # Returns an instance of +Time+, either with the same UTC offset
+    # as +self+ or in the local system timezone depending on the setting
+    # of +ActiveSupport.to_time_preserves_timezone+.
+    def to_time
+      if preserve_timezone
+        @to_time_with_instance_offset ||= getlocal(utc_offset)
+      else
+        @to_time_with_system_offset ||= getlocal
+      end
+    end
+
     # So that +self+ <tt>acts_like?(:time)</tt>.
     def acts_like_time?
       true
@@ -428,7 +440,7 @@ module ActiveSupport
 
     def freeze
       # preload instance variables before freezing
-      period; utc; time; to_datetime
+      period; utc; time; to_datetime; to_time
       super
     end
 

data/lib/active_support/values/time_zone.rb

@@ -339,6 +339,41 @@ module ActiveSupport
       Time.at(secs).utc.in_time_zone(self)
     end
 
+    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
+    # of +self+ from an ISO 8601 string.
+    #
+    #   Time.zone = 'Hawaii'                     # => "Hawaii"
+    #   Time.zone.iso8601('1999-12-31T14:00:00') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
+    #
+    # If the time components are missing then they will be set to zero.
+    #
+    #   Time.zone = 'Hawaii'            # => "Hawaii"
+    #   Time.zone.iso8601('1999-12-31') # => Fri, 31 Dec 1999 00:00:00 HST -10:00
+    #
+    # If the string is invalid then an +ArgumentError+ will be raised unlike +parse+
+    # which returns +nil+ when given an invalid date string.
+    def iso8601(str)
+      parts = Date._iso8601(str)
+
+      raise ArgumentError, "invalid date" if parts.empty?
+
+      time = Time.new(
+        parts.fetch(:year),
+        parts.fetch(:mon),
+        parts.fetch(:mday),
+        parts.fetch(:hour, 0),
+        parts.fetch(:min, 0),
+        parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
+        parts.fetch(:offset, 0)
+      )
+
+      if parts[:offset]
+        TimeWithZone.new(time.utc, self)
+      else
+        TimeWithZone.new(nil, self, time)
+      end
+    end
+
     # Method for creating new ActiveSupport::TimeWithZone instance in time zone
     # of +self+ from parsed string.
     #
@@ -359,6 +394,36 @@ module ActiveSupport
       parts_to_time(Date._parse(str, false), now)
     end
 
+    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
+    # of +self+ from an RFC 3339 string.
+    #
+    #   Time.zone = 'Hawaii'                     # => "Hawaii"
+    #   Time.zone.rfc3339('2000-01-01T00:00:00Z') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
+    #
+    # If the time or zone components are missing then an +ArgumentError+ will
+    # be raised. This is much stricter than either +parse+ or +iso8601+ which
+    # allow for missing components.
+    #
+    #   Time.zone = 'Hawaii'            # => "Hawaii"
+    #   Time.zone.rfc3339('1999-12-31') # => ArgumentError: invalid date
+    def rfc3339(str)
+      parts = Date._rfc3339(str)
+
+      raise ArgumentError, "invalid date" if parts.empty?
+
+      time = Time.new(
+        parts.fetch(:year),
+        parts.fetch(:mon),
+        parts.fetch(:mday),
+        parts.fetch(:hour),
+        parts.fetch(:min),
+        parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
+        parts.fetch(:offset)
+      )
+
+      TimeWithZone.new(time.utc, self)
+    end
+
     # Parses +str+ according to +format+ and returns an ActiveSupport::TimeWithZone.
     #
     # Assumes that +str+ is a time in the time zone +self+,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activesupport
 version: !ruby/object:Gem::Version
-  version: 5.1.0.beta1
+  version: 5.1.0.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2017-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n