activesupport 5.0.7.2 → 5.1.7

data/lib/active_support/dependencies/interlock.rb

@@ -1,4 +1,4 @@
-require 'active_support/concurrency/share_lock'
+require "active_support/concurrency/share_lock"
 
 module ActiveSupport #:nodoc:
   module Dependencies #:nodoc:

data/lib/active_support/deprecation.rb

@@ -1,4 +1,4 @@
-require 'singleton'
+require "singleton"
 
 module ActiveSupport
   # \Deprecation specifies the API used by Rails to deprecate methods, instance
@@ -12,12 +12,13 @@ module ActiveSupport
     # a circular require warning for active_support/deprecation.rb.
     #
     # So, we define the constant first, and load dependencies later.
-    require 'active_support/deprecation/instance_delegator'
-    require 'active_support/deprecation/behaviors'
-    require 'active_support/deprecation/reporting'
-    require 'active_support/deprecation/method_wrappers'
-    require 'active_support/deprecation/proxy_wrappers'
-    require 'active_support/core_ext/module/deprecation'
+    require "active_support/deprecation/instance_delegator"
+    require "active_support/deprecation/behaviors"
+    require "active_support/deprecation/reporting"
+    require "active_support/deprecation/constant_accessor"
+    require "active_support/deprecation/method_wrappers"
+    require "active_support/deprecation/proxy_wrappers"
+    require "active_support/core_ext/module/deprecation"
 
     include Singleton
     include InstanceDelegator
@@ -32,7 +33,7 @@ module ActiveSupport
     # and the second is a library name
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = '5.1', gem_name = 'Rails')
+    def initialize(deprecation_horizon = "5.2", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.

data/lib/active_support/deprecation/behaviors.rb

@@ -2,7 +2,7 @@ require "active_support/notifications"
 
 module ActiveSupport
   # Raised when <tt>ActiveSupport::Deprecation::Behavior#behavior</tt> is set with <tt>:raise</tt>.
-  # You would set <tt>:raise</tt>, as a behaviour to raise errors and proactively report exceptions from deprecations.
+  # You would set <tt>:raise</tt>, as a behavior to raise errors and proactively report exceptions from deprecations.
   class DeprecationException < StandardError
   end
 
@@ -25,7 +25,7 @@ module ActiveSupport
             if defined?(Rails.logger) && Rails.logger
               Rails.logger
             else
-              require 'active_support/logger'
+              require "active_support/logger"
               ActiveSupport::Logger.new($stderr)
             end
         logger.warn message
@@ -34,7 +34,7 @@ module ActiveSupport
 
       notify: ->(message, callstack) {
         ActiveSupport::Notifications.instrument("deprecation.rails",
-                                                :message => message, :callstack => callstack)
+                                                message: message, callstack: callstack)
       },
 
       silence: ->(message, callstack) {},

data/lib/active_support/deprecation/constant_accessor.rb

@@ -0,0 +1,50 @@
+require "active_support/inflector/methods"
+
+module ActiveSupport
+  class Deprecation
+    # DeprecatedConstantAccessor transforms a constant into a deprecated one by
+    # hooking +const_missing+.
+    #
+    # It takes the names of an old (deprecated) constant and of a new constant
+    # (both in string form) and optionally a deprecator. The deprecator defaults
+    # to +ActiveSupport::Deprecator+ if none is specified.
+    #
+    # The deprecated constant now returns the same object as the new one rather
+    # than a proxy object, so it can be used transparently in +rescue+ blocks
+    # etc.
+    #
+    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
+    #
+    #   (In a later update, the original implementation of `PLANETS` has been removed.)
+    #
+    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+    #   include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+    #   deprecate_constant 'PLANETS', 'PLANETS_POST_2006'
+    #
+    #   PLANETS.map { |planet| planet.capitalize }
+    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
+    #        (Backtrace information…)
+    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+    module DeprecatedConstantAccessor
+      def self.included(base)
+        extension = Module.new do
+          def const_missing(missing_const_name)
+            if class_variable_defined?(:@@_deprecated_constants)
+              if (replacement = class_variable_get(:@@_deprecated_constants)[missing_const_name.to_s])
+                replacement[:deprecator].warn(replacement[:message] || "#{name}::#{missing_const_name} is deprecated! Use #{replacement[:new]} instead.", caller_locations)
+                return ActiveSupport::Inflector.constantize(replacement[:new].to_s)
+              end
+            end
+            super
+          end
+
+          def deprecate_constant(const_name, new_constant, message: nil, deprecator: ActiveSupport::Deprecation.instance)
+            class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
+            class_variable_get(:@@_deprecated_constants)[const_name.to_s] = { new: new_constant, message: message, deprecator: deprecator }
+          end
+        end
+        base.singleton_class.prepend extension
+      end
+    end
+  end
+end

data/lib/active_support/deprecation/instance_delegator.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/delegation'
+require "active_support/core_ext/kernel/singleton_class"
+require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
   class Deprecation

data/lib/active_support/deprecation/method_wrappers.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/array/extract_options'
+require "active_support/core_ext/module/aliasing"
+require "active_support/core_ext/array/extract_options"
 
 module ActiveSupport
   class Deprecation
@@ -18,7 +18,7 @@ module ActiveSupport
       #
       # Using the default deprecator:
       #   ActiveSupport::Deprecation.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
-      #   # => [:aaa, :bbb, :ccc]
+      #   # => Fred
       #
       #   Fred.aaa
       #   # DEPRECATION WARNING: aaa is deprecated and will be removed from Rails 5.1. (called from irb_binding at (irb):10)
@@ -60,6 +60,13 @@ module ActiveSupport
               deprecator.deprecation_warning(method_name, options[method_name])
               super(*args, &block)
             end
+
+            case
+            when target_module.protected_method_defined?(method_name)
+              protected method_name
+            when target_module.private_method_defined?(method_name)
+              private method_name
+            end
           end
         end
 

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -1,4 +1,5 @@
-require 'active_support/inflector/methods'
+require "active_support/inflector/methods"
+require "active_support/core_ext/regexp"
 
 module ActiveSupport
   class Deprecation
@@ -10,7 +11,7 @@ module ActiveSupport
         super
       end
 
-      instance_methods.each { |m| undef_method m unless m =~ /^__|^object_id$/ }
+      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
 
       # Don't give a deprecation warning on inspect since test/unit and error
       # logs rely on it for diagnostics.
@@ -121,10 +122,11 @@ module ActiveSupport
     #        (Backtrace information…)
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     class DeprecatedConstantProxy < DeprecationProxy
-      def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance)
+      def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
         @old_const = old_const
         @new_const = new_const
         @deprecator = deprecator
+        @message = message
       end
 
       # Returns the class of the new constant.
@@ -142,7 +144,7 @@ module ActiveSupport
         end
 
         def warn(callstack, called, args)
-          @deprecator.warn("#{@old_const} is deprecated! Use #{@new_const} instead.", callstack)
+          @deprecator.warn(@message, callstack)
         end
     end
   end

data/lib/active_support/deprecation/reporting.rb

@@ -1,4 +1,4 @@
-require 'rbconfig'
+require "rbconfig"
 
 module ActiveSupport
   class Deprecation
@@ -48,17 +48,17 @@ module ActiveSupport
       private
         # Outputs a deprecation warning message
         #
-        #   ActiveSupport::Deprecation.deprecated_method_warning(:method_name)
+        #   deprecated_method_warning(:method_name)
         #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon}"
-        #   ActiveSupport::Deprecation.deprecated_method_warning(:method_name, :another_method)
+        #   deprecated_method_warning(:method_name, :another_method)
         #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (use another_method instead)"
-        #   ActiveSupport::Deprecation.deprecated_method_warning(:method_name, "Optional message")
+        #   deprecated_method_warning(:method_name, "Optional message")
         #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (Optional message)"
         def deprecated_method_warning(method_name, message = nil)
           warning = "#{method_name} is deprecated and will be removed from #{gem_name} #{deprecation_horizon}"
           case message
-            when Symbol then "#{warning} (use #{message} instead)"
-            when String then "#{warning} (#{message})"
+          when Symbol then "#{warning} (use #{message} instead)"
+          when String then "#{warning} (#{message})"
             else warning
           end
         end
@@ -105,7 +105,7 @@ module ActiveSupport
         RAILS_GEM_ROOT = File.expand_path("../../../../..", __FILE__) + "/"
 
         def ignored_callstack(path)
-          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG['rubylibdir'])
+          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
         end
     end
   end

data/lib/active_support/duration.rb

@@ -1,5 +1,8 @@
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/object/acts_like'
+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,12 +10,106 @@ 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)
+        if Duration === other
+          seconds   = value + other.parts[:seconds]
+          new_parts = other.parts.merge(seconds: seconds)
+          new_value = value + other.value
+
+          Duration.new(new_value, new_parts)
+        else
+          calculate(:+, other)
+        end
+      end
+
+      def -(other)
+        if Duration === other
+          seconds   = value - other.parts[:seconds]
+          new_parts = other.parts.map { |part, other_value| [part, -other_value] }.to_h
+          new_parts = new_parts.merge(seconds: seconds)
+          new_value = value - other.value
+
+          Duration.new(new_value, new_parts)
+        else
+          calculate(:-, other)
+        end
+      end
+
+      def *(other)
+        if Duration === other
+          new_parts = other.parts.map { |part, other_value| [part, value * other_value] }.to_h
+          new_value = value * other.value
+
+          Duration.new(new_value, new_parts)
+        else
+          calculate(:*, other)
+        end
+      end
+
+      def /(other)
+        if Duration === other
+          value / other.value
+        else
+          calculate(:/, other)
+        end
+      end
+
+      def %(other)
+        if Duration === other
+          Duration.build(value % other.value)
+        else
+          calculate(:%, other)
+        end
+      end
+
+      private
+        def calculate(op, other)
+          if Scalar === other
+            Scalar.new(value.public_send(op, other.value))
+          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
     SECONDS_PER_WEEK   = 604800
-    SECONDS_PER_MONTH  = 2592000  # 30 days
-    SECONDS_PER_YEAR   = 31557600 # length of a julian year (365.2425 days)
+    SECONDS_PER_MONTH  = 2629746  # 1/12 of a gregorian year
+    SECONDS_PER_YEAR   = 31556952 # length of a gregorian year (365.2425 days)
 
     PARTS_IN_SECONDS = {
       seconds: 1,
@@ -24,10 +121,12 @@ module ActiveSupport
       years:   SECONDS_PER_YEAR
     }.freeze
 
+    PARTS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
+
     attr_accessor :value, :parts
 
-    autoload :ISO8601Parser,     'active_support/duration/iso8601_parser'
-    autoload :ISO8601Serializer, 'active_support/duration/iso8601_serializer'
+    autoload :ISO8601Parser,     "active_support/duration/iso8601_parser"
+    autoload :ISO8601Serializer, "active_support/duration/iso8601_serializer"
 
     class << self
       # Creates a new Duration from string formatted according to ISO 8601 Duration.
@@ -74,6 +173,30 @@ module ActiveSupport
         new(value * SECONDS_PER_YEAR, [[:years, value]])
       end
 
+      # Creates a new Duration from a seconds value that is converted
+      # to the individual parts:
+      #
+      #   ActiveSupport::Duration.build(31556952).parts # => {:years=>1}
+      #   ActiveSupport::Duration.build(2716146).parts  # => {:months=>1, :days=>1}
+      #
+      def build(value)
+        parts = {}
+        remainder = value.to_f
+
+        PARTS.each do |part|
+          unless part == :seconds
+            part_in_seconds = PARTS_IN_SECONDS[part]
+            parts[part] = remainder.div(part_in_seconds)
+            remainder = (remainder % part_in_seconds).round(9)
+          end
+        end
+
+        parts[:seconds] = remainder
+        parts.reject! { |k, v| v.zero? }
+
+        new(value, parts)
+      end
+
       private
 
         def calculate_total_seconds(parts)
@@ -84,16 +207,40 @@ module ActiveSupport
     end
 
     def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts
+      @value, @parts = value, parts.to_h
+      @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)
       if Duration === other
-        Duration.new(value + other.value, @parts + other.parts)
+        parts = @parts.dup
+        other.parts.each do |(key, value)|
+          parts[key] += value
+        end
+        Duration.new(value + other.value, parts)
       else
-        Duration.new(value + other, @parts + [[:seconds, other]])
+        seconds = @parts[:seconds] + other
+        Duration.new(value + other, @parts.merge(seconds: seconds))
       end
     end
 
@@ -103,8 +250,44 @@ 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.new(value / other.value, parts.map { |type, number| [type, number / other.value] })
+      elsif Duration === other
+        value / other.value
+      elsif Numeric === other
+        Duration.new(value / other, parts.map { |type, number| [type, number / other] })
+      else
+        raise_type_error(other)
+      end
+    end
+
+    # Returns the modulo of this Duration by another Duration or Numeric.
+    # Numeric values are treated as seconds.
+    def %(other)
+      if Duration === other || Scalar === other
+        Duration.build(value % other.value)
+      elsif Numeric === other
+        Duration.build(value % other)
+      else
+        raise_type_error(other)
+      end
+    end
+
     def -@ #:nodoc:
-      Duration.new(-value, parts.map { |type,number| [type, -number] })
+      Duration.new(-value, parts.map { |type, number| [type, -number] })
     end
 
     def is_a?(klass) #:nodoc:
@@ -141,14 +324,14 @@ module ActiveSupport
     #   1.day.to_i      # => 86400
     #
     # Note that this conversion makes some assumptions about the
-    # duration of some periods, e.g. months are always 30 days
-    # and years are 365.25 days:
+    # duration of some periods, e.g. months are always 1/12 of year
+    # and years are 365.2425 days:
     #
-    #   # equivalent to 30.days.to_i
-    #   1.month.to_i    # => 2592000
+    #   # equivalent to (1.year / 12).to_i
+    #   1.month.to_i    # => 2629746
     #
-    #   # equivalent to 365.25.days.to_i
-    #   1.year.to_i     # => 31557600
+    #   # equivalent to 365.2425.days.to_i
+    #   1.year.to_i     # => 31556952
     #
     # In such cases, Ruby's core
     # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
@@ -174,6 +357,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.
@@ -181,12 +365,13 @@ module ActiveSupport
       sum(-1, time)
     end
     alias :until :ago
+    alias :before :ago
 
     def inspect #:nodoc:
       parts.
-        reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
-        sort_by {|unit,  _ | [:years, :months, :weeks, :days, :hours, :minutes, :seconds].index(unit)}.
-        map     {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}"}.
+        reduce(::Hash.new(0)) { |h, (l, r)| h[l] += r; h }.
+        sort_by { |unit,  _ | PARTS.index(unit) }.
+        map     { |unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" }.
         to_sentence(locale: ::I18n.default_locale)
     end
 
@@ -194,22 +379,28 @@ module ActiveSupport
       to_i
     end
 
-    def respond_to_missing?(method, include_private=false) #:nodoc:
+    def respond_to_missing?(method, include_private = false) #:nodoc:
       @value.respond_to?(method, include_private)
     end
 
+    def init_with(coder) #:nodoc:
+      initialize(coder["value"], coder["parts"])
+    end
+
+    def encode_with(coder) #:nodoc:
+      coder.map = { "value" => @value, "parts" => @parts }
+    end
+
     # Build ISO 8601 Duration string for this duration.
     # The +precision+ parameter can be used to limit seconds' precision of duration.
     def iso8601(precision: nil)
       ISO8601Serializer.new(self, precision: precision).serialize
     end
 
-    delegate :<=>, to: :value
-
-    protected
+    private
 
-      def sum(sign, time = ::Time.current) #:nodoc:
-        parts.inject(time) do |t,(type,number)|
+      def sum(sign, time = ::Time.current)
+        parts.inject(time) do |t, (type, number)|
           if t.acts_like?(:time) || t.acts_like?(:date)
             if type == :seconds
               t.since(sign * number)
@@ -226,10 +417,12 @@ module ActiveSupport
         end
       end
 
-    private
-
-      def method_missing(method, *args, &block) #:nodoc:
+      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