activesupport 5.0.0 → 6.1.0

data/lib/active_support/duration/iso8601_parser.rb

@@ -1,18 +1,20 @@
-require 'strscan'
+# frozen_string_literal: true
+
+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.
+    # See {ISO 8601}[https://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
+      PERIOD = "."
+      COMMA = ","
 
       SIGN_MARKER = /\A\-|\+|/
       DATE_MARKER = /P/
@@ -20,8 +22,8 @@ module ActiveSupport
       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_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]
@@ -39,36 +41,36 @@ module ActiveSupport
       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
+          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
@@ -78,45 +80,44 @@ module ActiveSupport
       end
 
       private
+        def finished?
+          scanner.eos?
+        end
 
-      def finished?
-        scanner.eos?
-      end
+        # Parses number which can be a float with either comma or period.
+        def number
+          PERIOD_OR_COMMA.match?(scanner[1]) ? scanner[1].tr(COMMA, PERIOD).to_f : scanner[1].to_i
+        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 scan(pattern)
-        scanner.scan(pattern)
-      end
+        def raise_parsing_error(reason = nil)
+          raise ParsingError, "Invalid ISO 8601 duration: #{scanner.string.inspect} #{reason}".strip
+        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?
 
-      # 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
 
-        # 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
 
-        # 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
 
-        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)'
+          true
         end
-
-        return true
-      end
     end
   end
 end

data/lib/active_support/duration/iso8601_serializer.rb

@@ -1,10 +1,13 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/transform_values'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
 
 module ActiveSupport
   class Duration
     # Serializes duration to string according to ISO 8601 Duration format.
-    class ISO8601Serializer
+    class ISO8601Serializer # :nodoc:
+      DATE_COMPONENTS = %i(years months days)
+
       def initialize(duration, precision: nil)
         @duration = duration
         @precision = precision
@@ -12,39 +15,44 @@ module ActiveSupport
 
       # Builds and returns output string.
       def serialize
-        output = 'P'
-        parts, sign = normalize
+        parts = normalize
+        return "PT0S" if parts.empty?
+
+        output = +"P"
         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 = ''
+        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
+        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}"
+        output << "T#{time}" unless time.empty?
+        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|
+          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!(&:-@)
+
+          # Convert weeks to days and remove weeks if mixed with date parts
+          if week_mixed_with_date?(parts)
+            parts[:days] += parts.delete(:weeks) * SECONDS_PER_WEEK / SECONDS_PER_DAY
           end
-          [parts, sign]
+
+          parts
+        end
+
+        def week_mixed_with_date?(parts)
+          parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
         end
     end
   end