activesupport 6.0.0

data/lib/active_support/duration/iso8601_parser.rb

@@ -0,0 +1,124 @@
+# 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 & 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
+
+          true
+        end
+    end
+  end
+end

data/lib/active_support/duration/iso8601_serializer.rb

@@ -0,0 +1,54 @@
+# 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 # :nodoc:
+      def initialize(duration, precision: nil)
+        @duration = duration
+        @precision = precision
+      end
+
+      # Builds and returns output string.
+      def serialize
+        parts, sign = 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 = +""
+        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}" unless time.empty?
+        "#{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/encrypted_configuration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "active_support/encrypted_file"
+require "active_support/ordered_options"
+require "active_support/core_ext/object/inclusion"
+require "active_support/core_ext/module/delegation"
+
+module ActiveSupport
+  class EncryptedConfiguration < EncryptedFile
+    delegate :[], :fetch, to: :config
+    delegate_missing_to :options
+
+    def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
+      super content_path: config_path, key_path: key_path,
+        env_key: env_key, raise_if_missing_key: raise_if_missing_key
+    end
+
+    # Allow a config to be started without a file present
+    def read
+      super
+    rescue ActiveSupport::EncryptedFile::MissingContentError
+      ""
+    end
+
+    def write(contents)
+      deserialize(contents)
+
+      super
+    end
+
+    def config
+      @config ||= deserialize(read).deep_symbolize_keys
+    end
+
+    private
+      def options
+        @options ||= ActiveSupport::InheritableOptions.new(config)
+      end
+
+      def deserialize(config)
+        YAML.load(config).presence || {}
+      end
+  end
+end

data/lib/active_support/encrypted_file.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "tmpdir"
+require "active_support/message_encryptor"
+
+module ActiveSupport
+  class EncryptedFile
+    class MissingContentError < RuntimeError
+      def initialize(content_path)
+        super "Missing encrypted content file in #{content_path}."
+      end
+    end
+
+    class MissingKeyError < RuntimeError
+      def initialize(key_path:, env_key:)
+        super \
+          "Missing encryption key to decrypt file with. " +
+          "Ask your team for your master key and write it to #{key_path} or put it in the ENV['#{env_key}']."
+      end
+    end
+
+    CIPHER = "aes-128-gcm"
+
+    def self.generate_key
+      SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
+    end
+
+
+    attr_reader :content_path, :key_path, :env_key, :raise_if_missing_key
+
+    def initialize(content_path:, key_path:, env_key:, raise_if_missing_key:)
+      @content_path, @key_path = Pathname.new(content_path), Pathname.new(key_path)
+      @env_key, @raise_if_missing_key = env_key, raise_if_missing_key
+    end
+
+    def key
+      read_env_key || read_key_file || handle_missing_key
+    end
+
+    def read
+      if !key.nil? && content_path.exist?
+        decrypt content_path.binread
+      else
+        raise MissingContentError, content_path
+      end
+    end
+
+    def write(contents)
+      IO.binwrite "#{content_path}.tmp", encrypt(contents)
+      FileUtils.mv "#{content_path}.tmp", content_path
+    end
+
+    def change(&block)
+      writing read, &block
+    end
+
+
+    private
+      def writing(contents)
+        tmp_file = "#{Process.pid}.#{content_path.basename.to_s.chomp('.enc')}"
+        tmp_path = Pathname.new File.join(Dir.tmpdir, tmp_file)
+        tmp_path.binwrite contents
+
+        yield tmp_path
+
+        updated_contents = tmp_path.binread
+
+        write(updated_contents) if updated_contents != contents
+      ensure
+        FileUtils.rm(tmp_path) if tmp_path&.exist?
+      end
+
+
+      def encrypt(contents)
+        encryptor.encrypt_and_sign contents
+      end
+
+      def decrypt(contents)
+        encryptor.decrypt_and_verify contents
+      end
+
+      def encryptor
+        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER)
+      end
+
+
+      def read_env_key
+        ENV[env_key]
+      end
+
+      def read_key_file
+        key_path.binread.strip if key_path.exist?
+      end
+
+      def handle_missing_key
+        raise MissingKeyError, key_path: key_path, env_key: env_key if raise_if_missing_key
+      end
+  end
+end

data/lib/active_support/evented_file_update_checker.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "set"
+require "pathname"
+require "concurrent/atomic/atomic_boolean"
+
+module ActiveSupport
+  # Allows you to "listen" to changes in a file system.
+  # The evented file updater does not hit disk when checking for updates
+  # instead it uses platform specific file system events to trigger a change
+  # in state.
+  #
+  # The file checker takes an array of files to watch or a hash specifying directories
+  # and file extensions to watch. It also takes a block that is called when
+  # EventedFileUpdateChecker#execute is run or when EventedFileUpdateChecker#execute_if_updated
+  # is run and there have been changes to the file system.
+  #
+  # Note: Forking will cause the first call to `updated?` to return `true`.
+  #
+  # Example:
+  #
+  #     checker = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
+  #     checker.updated?
+  #     # => false
+  #     checker.execute_if_updated
+  #     # => nil
+  #
+  #     FileUtils.touch("/tmp/foo")
+  #
+  #     checker.updated?
+  #     # => true
+  #     checker.execute_if_updated
+  #     # => "changed"
+  #
+  class EventedFileUpdateChecker #:nodoc: all
+    def initialize(files, dirs = {}, &block)
+      unless block
+        raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"
+      end
+
+      @ph    = PathHelper.new
+      @files = files.map { |f| @ph.xpath(f) }.to_set
+
+      @dirs = {}
+      dirs.each do |dir, exts|
+        @dirs[@ph.xpath(dir)] = Array(exts).map { |ext| @ph.normalize_extension(ext) }
+      end
+
+      @block      = block
+      @updated    = Concurrent::AtomicBoolean.new(false)
+      @lcsp       = @ph.longest_common_subpath(@dirs.keys)
+      @pid        = Process.pid
+      @boot_mutex = Mutex.new
+
+      dtw = directories_to_watch
+      @dtw, @missing = dtw.partition(&:exist?)
+
+      if @dtw.any?
+        # Loading listen triggers warnings. These are originated by a legit
+        # usage of attr_* macros for private attributes, but adds a lot of noise
+        # to our test suite. Thus, we lazy load it and disable warnings locally.
+        silence_warnings do
+          require "listen"
+        rescue LoadError => e
+          raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
+        end
+      end
+      boot!
+    end
+
+    def updated?
+      @boot_mutex.synchronize do
+        if @pid != Process.pid
+          boot!
+          @pid = Process.pid
+          @updated.make_true
+        end
+      end
+
+      if @missing.any?(&:exist?)
+        @boot_mutex.synchronize do
+          appeared, @missing = @missing.partition(&:exist?)
+          shutdown!
+
+          @dtw += appeared
+          boot!
+
+          @updated.make_true
+        end
+      end
+
+      @updated.true?
+    end
+
+    def execute
+      @updated.make_false
+      @block.call
+    end
+
+    def execute_if_updated
+      if updated?
+        yield if block_given?
+        execute
+        true
+      end
+    end
+
+    private
+      def boot!
+        normalize_dirs!
+
+        unless @dtw.empty?
+          Listen.to(*@dtw, &method(:changed)).start
+        end
+      end
+
+      def shutdown!
+        Listen.stop
+      end
+
+      def normalize_dirs!
+        @dirs.transform_keys! do |dir|
+          dir.exist? ? dir.realpath : dir
+        end
+      end
+
+      def changed(modified, added, removed)
+        unless updated?
+          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
+        end
+      end
+
+      def watching?(file)
+        file = @ph.xpath(file)
+
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = @ph.normalize_extension(file.extname)
+
+          file.dirname.ascend do |dir|
+            matching = @dirs[dir]
+
+            if matching && (matching.empty? || matching.include?(ext))
+              break true
+            elsif dir == @lcsp || dir.root?
+              break false
+            end
+          end
+        end
+      end
+
+      def directories_to_watch
+        dtw = @files.map(&:dirname) + @dirs.keys
+        dtw.compact!
+        dtw.uniq!
+
+        normalized_gem_paths = Gem.path.map { |path| File.join path, "" }
+        dtw = dtw.reject do |path|
+          normalized_gem_paths.any? { |gem_path| path.to_s.start_with?(gem_path) }
+        end
+
+        @ph.filter_out_descendants(dtw)
+      end
+
+      class PathHelper
+        def xpath(path)
+          Pathname.new(path).expand_path
+        end
+
+        def normalize_extension(ext)
+          ext.to_s.sub(/\A\./, "")
+        end
+
+        # Given a collection of Pathname objects returns the longest subpath
+        # common to all of them, or +nil+ if there is none.
+        def longest_common_subpath(paths)
+          return if paths.empty?
+
+          lcsp = Pathname.new(paths[0])
+
+          paths[1..-1].each do |path|
+            until ascendant_of?(lcsp, path)
+              if lcsp.root?
+                # If we get here a root directory is not an ascendant of path.
+                # This may happen if there are paths in different drives on
+                # Windows.
+                return
+              else
+                lcsp = lcsp.parent
+              end
+            end
+          end
+
+          lcsp
+        end
+
+        # Returns the deepest existing ascendant, which could be the argument itself.
+        def existing_parent(dir)
+          dir.ascend do |ascendant|
+            break ascendant if ascendant.directory?
+          end
+        end
+
+        # Filters out directories which are descendants of others in the collection (stable).
+        def filter_out_descendants(dirs)
+          return dirs if dirs.length < 2
+
+          dirs_sorted_by_nparts = dirs.sort_by { |dir| dir.each_filename.to_a.length }
+          descendants = []
+
+          until dirs_sorted_by_nparts.empty?
+            dir = dirs_sorted_by_nparts.shift
+
+            dirs_sorted_by_nparts.reject! do |possible_descendant|
+              ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
+            end
+          end
+
+          # Array#- preserves order.
+          dirs - descendants
+        end
+
+        private
+
+          def ascendant_of?(base, other)
+            base != other && other.ascend do |ascendant|
+              break true if base == ascendant
+            end
+          end
+      end
+  end
+end