activesupport 1.2.4 → 8.1.2

data/lib/active_support/descendants_tracker.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+module ActiveSupport
+  # = Active Support Descendants Tracker
+  #
+  # This module provides an internal implementation to track descendants
+  # which is faster than iterating through +ObjectSpace+.
+  #
+  # However Ruby 3.1 provide a fast native +Class#subclasses+ method,
+  # so if you know your code won't be executed on older rubies, including
+  # +ActiveSupport::DescendantsTracker+ does not provide any benefit.
+  module DescendantsTracker
+    @clear_disabled = false
+
+    if RUBY_ENGINE == "ruby"
+      # On MRI `ObjectSpace::WeakMap` keys are weak references.
+      # So we can simply use WeakMap as a `Set`.
+      class WeakSet < ObjectSpace::WeakMap # :nodoc:
+        alias_method :to_a, :keys
+
+        def <<(object)
+          self[object] = true
+        end
+      end
+    else
+      # On TruffleRuby `ObjectSpace::WeakMap` keys are strong references.
+      # So we use `object_id` as a key and the actual object as a value.
+      #
+      # JRuby for now doesn't have Class#descendant, but when it will, it will likely
+      # have the same WeakMap semantic than Truffle so we future proof this as much as possible.
+      class WeakSet # :nodoc:
+        def initialize
+          @map = ObjectSpace::WeakMap.new
+        end
+
+        def [](object)
+          @map.key?(object.object_id)
+        end
+        alias_method :include?, :[]
+
+        def []=(object, _present)
+          @map[object.object_id] = object
+        end
+
+        def to_a
+          @map.values
+        end
+
+        def <<(object)
+          self[object] = true
+        end
+      end
+    end
+    @excluded_descendants = WeakSet.new
+
+    module ReloadedClassesFiltering # :nodoc:
+      def subclasses
+        DescendantsTracker.reject!(super)
+      end
+
+      def descendants
+        DescendantsTracker.reject!(super)
+      end
+    end
+
+    class << self
+      def disable_clear! # :nodoc:
+        unless @clear_disabled
+          @clear_disabled = true
+          ReloadedClassesFiltering.remove_method(:subclasses)
+          ReloadedClassesFiltering.remove_method(:descendants)
+          @excluded_descendants = nil
+        end
+      end
+
+      def clear(classes) # :nodoc:
+        raise "DescendantsTracker.clear was disabled because config.enable_reloading is false" if @clear_disabled
+
+        classes.each do |klass|
+          @excluded_descendants << klass
+          klass.descendants.each do |descendant|
+            @excluded_descendants << descendant
+          end
+        end
+      end
+
+      def reject!(classes) # :nodoc:
+        if @excluded_descendants
+          classes.reject! { |d| @excluded_descendants.include?(d) }
+        end
+        classes
+      end
+    end
+
+    class << self
+      def subclasses(klass)
+        klass.subclasses
+      end
+
+      def descendants(klass)
+        klass.descendants
+      end
+    end
+
+    def descendants
+      subclasses = DescendantsTracker.reject!(self.subclasses)
+      subclasses.concat(subclasses.flat_map(&:descendants))
+    end
+  end
+end

data/lib/active_support/digest.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ActiveSupport
+  class Digest # :nodoc:
+    class << self
+      def hash_digest_class
+        @hash_digest_class ||= OpenSSL::Digest::MD5
+      end
+
+      def hash_digest_class=(klass)
+        raise ArgumentError, "#{klass} is expected to implement hexdigest class method" unless klass.respond_to?(:hexdigest)
+        @hash_digest_class = klass
+      end
+
+      def hexdigest(arg)
+        hash_digest_class.hexdigest(arg)[0...32]
+      end
+    end
+  end
+end

data/lib/active_support/duration/iso8601_parser.rb

@@ -0,0 +1,123 @@
+# 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}[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 = "."
+      COMMA = ","
+
+      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
+          PERIOD_OR_COMMA.match?(scanner[1]) ? 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.intersect?(DATE_COMPONENTS)
+            raise_parsing_error("mixing weeks with other date parts not allowed")
+          end
+
+          # Specifying an empty T part is invalid.
+          if mode == :time && !parts.keys.intersect?(TIME_COMPONENTS)
+            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
+
+          true
+        end
+    end
+  end
+end

data/lib/active_support/duration/iso8601_serializer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Duration
+    # Serializes duration to string according to ISO 8601 Duration format.
+    class ISO8601Serializer # :nodoc:
+      DATE_COMPONENTS = %i(years months days)
+
+      def initialize(duration, precision: nil)
+        @duration = duration
+        @precision = precision
+      end
+
+      # Builds and returns output string.
+      def serialize
+        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[:days]}D"    if parts.key?(:days)
+        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 << "#{format_seconds(parts[:seconds])}S"
+        end
+        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.
+        def normalize
+          parts = @duration.parts.each_with_object(Hash.new(0)) do |(k, v), p|
+            p[k] += v  unless v.zero?
+          end
+
+          # 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
+        end
+
+        def week_mixed_with_date?(parts)
+          parts.key?(:weeks) && parts.keys.intersect?(DATE_COMPONENTS)
+        end
+
+        def format_seconds(seconds)
+          if @precision
+            sprintf("%0.0#{@precision}f", seconds)
+          else
+            seconds.to_s
+          end
+        end
+    end
+  end
+end