activesupport 4.2.11.3 → 5.0.7.2

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -20,20 +20,22 @@ module ActiveSupport
 
       private
         def method_missing(called, *args, &block)
-          warn caller, called, args
+          warn caller_locations, called, args
           target.__send__(called, *args, &block)
         end
     end
 
-    # This DeprecatedObjectProxy transforms object to deprecated object.
+    # DeprecatedObjectProxy transforms an object into a deprecated one. It
+    # takes an object, a deprecation message and optionally a deprecator. The
+    # deprecator defaults to +ActiveSupport::Deprecator+ if none is specified.
     #
-    #   @old_object = DeprecatedObjectProxy.new(Object.new, "Don't use this object anymore!")
-    #   @old_object = DeprecatedObjectProxy.new(Object.new, "Don't use this object anymore!", deprecator_instance)
+    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")
+    #   # => #<Object:0x007fb9b34c34b0>
     #
-    # When someone executes any method except +inspect+ on proxy object this will
-    # trigger +warn+ method on +deprecator_instance+.
-    #
-    # Default deprecator is <tt>ActiveSupport::Deprecation</tt>
+    #   deprecated_object.to_s
+    #   DEPRECATION WARNING: This object is now deprecated.
+    #   (Backtrace)
+    #   # => "#<Object:0x007fb9b34c34b0>"
     class DeprecatedObjectProxy < DeprecationProxy
       def initialize(object, message, deprecator = ActiveSupport::Deprecation.instance)
         @object = object
@@ -51,13 +53,16 @@ module ActiveSupport
         end
     end
 
-    # This DeprecatedInstanceVariableProxy transforms instance variable to
-    # deprecated instance variable.
+    # DeprecatedInstanceVariableProxy transforms an instance variable into a
+    # deprecated one. It takes an instance of a class, a method on that class
+    # and an instance variable. It optionally takes a deprecator as the last
+    # argument. The deprecator defaults to +ActiveSupport::Deprecator+ if none
+    # is specified.
     #
     #   class Example
-    #     def initialize(deprecator)
-    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request, deprecator)
-    #       @_request = :a_request
+    #     def initialize
+    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request)
+    #       @_request = :special_request
     #     end
     #
     #     def request
@@ -69,12 +74,17 @@ module ActiveSupport
     #     end
     #   end
     #
-    # When someone execute any method on @request variable this will trigger
-    # +warn+ method on +deprecator_instance+ and will fetch <tt>@_request</tt>
-    # variable via +request+ method and execute the same method on non-proxy
-    # instance variable.
+    #   example = Example.new
+    #   # => #<Example:0x007fb9b31090b8 @_request=:special_request, @request=:special_request>
+    #
+    #   example.old_request.to_s
+    #   # => DEPRECATION WARNING: @request is deprecated! Call request.to_s instead of
+    #      @request.to_s
+    #      (Backtrace information…)
+    #      "special_request"
     #
-    # Default deprecator is <tt>ActiveSupport::Deprecation</tt>.
+    #   example.request.to_s
+    #   # => "special_request"
     class DeprecatedInstanceVariableProxy < DeprecationProxy
       def initialize(instance, method, var = "@#{method}", deprecator = ActiveSupport::Deprecation.instance)
         @instance = instance
@@ -93,15 +103,23 @@ module ActiveSupport
         end
     end
 
-    # This DeprecatedConstantProxy transforms constant to deprecated constant.
+    # DeprecatedConstantProxy transforms a constant into a deprecated one. 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 value of the new one.
+    #
+    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
     #
-    #   OLD_CONST = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('OLD_CONST', 'NEW_CONST')
-    #   OLD_CONST = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('OLD_CONST', 'NEW_CONST', deprecator_instance)
+    #   (In a later update, the original implementation of `PLANETS` has been removed.)
     #
-    # When someone use old constant this will trigger +warn+ method on
-    # +deprecator_instance+.
+    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
     #
-    # Default deprecator is <tt>ActiveSupport::Deprecation</tt>.
+    #   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"]
     class DeprecatedConstantProxy < DeprecationProxy
       def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance)
         @old_const = old_const
@@ -109,6 +127,11 @@ module ActiveSupport
         @deprecator = deprecator
       end
 
+      # Returns the class of the new constant.
+      #
+      #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+      #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+      #   PLANETS.class # => Array
       def class
         target.class
       end

data/lib/active_support/deprecation/reporting.rb

@@ -1,3 +1,5 @@
+require 'rbconfig'
+
 module ActiveSupport
   class Deprecation
     module Reporting
@@ -14,7 +16,7 @@ module ActiveSupport
       def warn(message = nil, callstack = nil)
         return if silenced
 
-        callstack ||= caller(2)
+        callstack ||= caller_locations(2)
         deprecation_message(callstack, message).tap do |m|
           behavior.each { |b| b.call(m, callstack) }
         end
@@ -37,7 +39,7 @@ module ActiveSupport
       end
 
       def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
-        caller_backtrace ||= caller(2)
+        caller_backtrace ||= caller_locations(2)
         deprecated_method_warning(deprecated_method_name, message).tap do |msg|
           warn(msg, caller_backtrace)
         end
@@ -63,7 +65,6 @@ module ActiveSupport
 
         def deprecation_message(callstack, message = nil)
           message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
-          message += '.' unless message =~ /\.$/
           "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
         end
 
@@ -79,8 +80,19 @@ module ActiveSupport
         end
 
         def extract_callstack(callstack)
-          rails_gem_root = File.expand_path("../../../../..", __FILE__) + "/"
-          offending_line = callstack.find { |line| !line.start_with?(rails_gem_root) } || callstack.first
+          return _extract_callstack(callstack) if callstack.first.is_a? String
+
+          offending_line = callstack.find { |frame|
+            frame.absolute_path && !ignored_callstack(frame.absolute_path)
+          } || callstack.first
+
+          [offending_line.path, offending_line.lineno, offending_line.label]
+        end
+
+        def _extract_callstack(callstack)
+          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
+          offending_line = callstack.find { |line| !ignored_callstack(line) } || callstack.first
+
           if offending_line
             if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
               md.captures
@@ -89,6 +101,12 @@ module ActiveSupport
             end
           end
         end
+
+        RAILS_GEM_ROOT = File.expand_path("../../../../..", __FILE__) + "/"
+
+        def ignored_callstack(path)
+          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG['rubylibdir'])
+        end
     end
   end
 end

data/lib/active_support/deprecation.rb

@@ -32,7 +32,7 @@ module ActiveSupport
     # and the second is a library name
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = '5.0', gem_name = 'Rails')
+    def initialize(deprecation_horizon = '5.1', 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/duration/iso8601_parser.rb

@@ -0,0 +1,122 @@
+require 'strscan'
+
+module ActiveSupport
+  class Duration
+    # Parses a string formatted according to ISO 8601 Duration into the hash.
+    #
+    # See {ISO 8601}[http://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+    #
+    # This parser allows negative parts to be present in pattern.
+    class ISO8601Parser # :nodoc:
+      class ParsingError < ::ArgumentError; end
+
+      PERIOD_OR_COMMA = /\.|,/
+      PERIOD = '.'.freeze
+      COMMA = ','.freeze
+
+      SIGN_MARKER = /\A\-|\+|/
+      DATE_MARKER = /P/
+      TIME_MARKER = /T/
+      DATE_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
+      TIME_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(H|M|S)/
+
+      DATE_TO_PART = { 'Y' => :years, 'M' => :months, 'W' => :weeks, 'D' => :days }
+      TIME_TO_PART = { 'H' => :hours, 'M' => :minutes, 'S' => :seconds }
+
+      DATE_COMPONENTS = [:years, :months, :days]
+      TIME_COMPONENTS = [:hours, :minutes, :seconds]
+
+      attr_reader :parts, :scanner
+      attr_accessor :mode, :sign
+
+      def initialize(string)
+        @scanner = StringScanner.new(string)
+        @parts = {}
+        @mode = :start
+        @sign = 1
+      end
+
+      def parse!
+        while !finished?
+          case mode
+            when :start
+              if scan(SIGN_MARKER)
+                self.sign = (scanner.matched == '-') ? -1 : 1
+                self.mode = :sign
+              else
+                raise_parsing_error
+              end
+
+            when :sign
+              if scan(DATE_MARKER)
+                self.mode = :date
+              else
+                raise_parsing_error
+              end
+
+            when :date
+              if scan(TIME_MARKER)
+                self.mode = :time
+              elsif scan(DATE_COMPONENT)
+                parts[DATE_TO_PART[scanner[2]]] = number * sign
+              else
+                raise_parsing_error
+              end
+
+            when :time
+              if scan(TIME_COMPONENT)
+                parts[TIME_TO_PART[scanner[2]]] = number * sign
+              else
+                raise_parsing_error
+              end
+
+          end
+        end
+
+        validate!
+        parts
+      end
+
+      private
+
+      def finished?
+        scanner.eos?
+      end
+
+      # Parses number which can be a float with either comma or period.
+      def number
+        scanner[1] =~ PERIOD_OR_COMMA ? scanner[1].tr(COMMA, PERIOD).to_f : scanner[1].to_i
+      end
+
+      def scan(pattern)
+        scanner.scan(pattern)
+      end
+
+      def raise_parsing_error(reason = nil)
+        raise ParsingError, "Invalid ISO 8601 duration: #{scanner.string.inspect} #{reason}".strip
+      end
+
+      # Checks for various semantic errors as stated in ISO 8601 standard.
+      def validate!
+        raise_parsing_error('is empty duration') if parts.empty?
+
+        # Mixing any of Y, M, D with W is invalid.
+        if parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
+          raise_parsing_error('mixing weeks with other date parts not allowed')
+        end
+
+        # Specifying an empty T part is invalid.
+        if mode == :time && (parts.keys & TIME_COMPONENTS).empty?
+          raise_parsing_error('time part marker is present but time part is empty')
+        end
+
+        fractions = parts.values.reject(&:zero?).select { |a| (a % 1) != 0 }
+        unless fractions.empty? || (fractions.size == 1 && fractions.last == @parts.values.reject(&:zero?).last)
+          raise_parsing_error '(only last part can be fractional)'
+        end
+
+        return true
+      end
+    end
+  end
+end

data/lib/active_support/duration/iso8601_serializer.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/transform_values'
+
+module ActiveSupport
+  class Duration
+    # Serializes duration to string according to ISO 8601 Duration format.
+    class ISO8601Serializer
+      def initialize(duration, precision: nil)
+        @duration = duration
+        @precision = precision
+      end
+
+      # Builds and returns output string.
+      def serialize
+        output = 'P'
+        parts, sign = normalize
+        output << "#{parts[:years]}Y"   if parts.key?(:years)
+        output << "#{parts[:months]}M"  if parts.key?(:months)
+        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
+        output << "#{parts[:days]}D"    if parts.key?(:days)
+        time = ''
+        time << "#{parts[:hours]}H"     if parts.key?(:hours)
+        time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
+        if parts.key?(:seconds)
+          time << "#{sprintf(@precision ? "%0.0#{@precision}f" : '%g', parts[:seconds])}S"
+        end
+        output << "T#{time}"  if time.present?
+        "#{sign}#{output}"
+      end
+
+      private
+
+        # Return pair of duration's parts and whole duration sign.
+        # Parts are summarized (as they can become repetitive due to addition, etc).
+        # Zero parts are removed as not significant.
+        # If all parts are negative it will negate all of them and return minus as a sign.
+        def normalize
+          parts = @duration.parts.each_with_object(Hash.new(0)) do |(k,v),p|
+            p[k] += v  unless v.zero?
+          end
+          # If all parts are negative - let's make a negative duration
+          sign = ''
+          if parts.values.all? { |v| v < 0 }
+            sign = '-'
+            parts.transform_values!(&:-@)
+          end
+          [parts, sign]
+        end
+    end
+  end
+end

data/lib/active_support/duration.rb

@@ -7,8 +7,82 @@ module ActiveSupport
   #
   #   1.month.ago       # equivalent to Time.now.advance(months: -1)
   class Duration
+    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)
+
+    PARTS_IN_SECONDS = {
+      seconds: 1,
+      minutes: SECONDS_PER_MINUTE,
+      hours:   SECONDS_PER_HOUR,
+      days:    SECONDS_PER_DAY,
+      weeks:   SECONDS_PER_WEEK,
+      months:  SECONDS_PER_MONTH,
+      years:   SECONDS_PER_YEAR
+    }.freeze
+
     attr_accessor :value, :parts
 
+    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.
+      #
+      # See {ISO 8601}[http://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+      # This method allows negative parts to be present in pattern.
+      # If invalid string is provided, it will raise +ActiveSupport::Duration::ISO8601Parser::ParsingError+.
+      def parse(iso8601duration)
+        parts = ISO8601Parser.new(iso8601duration).parse!
+        new(calculate_total_seconds(parts), parts)
+      end
+
+      def ===(other) #:nodoc:
+        other.is_a?(Duration)
+      rescue ::NoMethodError
+        false
+      end
+
+      def seconds(value) #:nodoc:
+        new(value, [[:seconds, value]])
+      end
+
+      def minutes(value) #:nodoc:
+        new(value * SECONDS_PER_MINUTE, [[:minutes, value]])
+      end
+
+      def hours(value) #:nodoc:
+        new(value * SECONDS_PER_HOUR, [[:hours, value]])
+      end
+
+      def days(value) #:nodoc:
+        new(value * SECONDS_PER_DAY, [[:days, value]])
+      end
+
+      def weeks(value) #:nodoc:
+        new(value * SECONDS_PER_WEEK, [[:weeks, value]])
+      end
+
+      def months(value) #:nodoc:
+        new(value * SECONDS_PER_MONTH, [[:months, value]])
+      end
+
+      def years(value) #:nodoc:
+        new(value * SECONDS_PER_YEAR, [[:years, value]])
+      end
+
+      private
+
+        def calculate_total_seconds(parts)
+          parts.inject(0) do |total, (part, value)|
+            total + value * PARTS_IN_SECONDS[part]
+          end
+        end
+    end
+
     def initialize(value, parts) #:nodoc:
       @value, @parts = value, parts
     end
@@ -52,6 +126,10 @@ module ActiveSupport
       end
     end
 
+    # Returns the amount of seconds a duration covers as a string.
+    # For more information check to_i method.
+    #
+    #   1.day.to_s # => "86400"
     def to_s
       @value.to_s
     end
@@ -90,12 +168,6 @@ module ActiveSupport
       @value.hash
     end
 
-    def self.===(other) #:nodoc:
-      other.is_a?(Duration)
-    rescue ::NoMethodError
-      false
-    end
-
     # Calculates a new Time or Date that is as far in the future
     # as this Duration represents.
     def since(time = ::Time.current)
@@ -113,7 +185,7 @@ module ActiveSupport
     def inspect #:nodoc:
       parts.
         reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
-        sort_by {|unit,  _ | [:years, :months, :days, :minutes, :seconds].index(unit)}.
+        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}"}.
         to_sentence(locale: ::I18n.default_locale)
     end
@@ -122,10 +194,16 @@ 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
 
+    # 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
@@ -135,6 +213,10 @@ module ActiveSupport
           if t.acts_like?(:time) || t.acts_like?(:date)
             if type == :seconds
               t.since(sign * number)
+            elsif type == :minutes
+              t.since(sign * number * 60)
+            elsif type == :hours
+              t.since(sign * number * 3600)
             else
               t.advance(type => sign * number)
             end
@@ -146,13 +228,6 @@ module ActiveSupport
 
     private
 
-      # We define it as a workaround to Ruby 2.0.0-p353 bug.
-      # For more information, check rails/rails#13055.
-      # Remove it when we drop support for 2.0.0-p353.
-      def ===(other) #:nodoc:
-        value === other
-      end
-
       def method_missing(method, *args, &block) #:nodoc:
         value.send(method, *args, &block)
       end