omg-activesupport 8.0.0.alpha1

data/lib/active_support/evented_file_update_checker.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+gem "listen", "~> 3.5"
+require "listen"
+
+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.
+  #
+  # 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
+
+      @block = block
+      @core = Core.new(files, dirs)
+      ObjectSpace.define_finalizer(self, @core.finalizer)
+    end
+
+    def inspect
+      "#<ActiveSupport::EventedFileUpdateChecker:#{object_id} @files=#{@core.files.to_a.inspect}"
+    end
+
+    def updated?
+      if @core.restart?
+        @core.thread_safely(&:restart)
+        @core.updated.make_true
+      end
+
+      @core.updated.true?
+    end
+
+    def execute
+      @core.updated.make_false
+      @block.call
+    end
+
+    def execute_if_updated
+      if updated?
+        yield if block_given?
+        execute
+        true
+      end
+    end
+
+    class Core
+      attr_reader :updated, :files
+
+      def initialize(files, dirs)
+        @files = files.map { |file| Pathname(file).expand_path }.to_set
+
+        @dirs = dirs.each_with_object({}) do |(dir, exts), hash|
+          hash[Pathname(dir).expand_path] = Array(exts).map { |ext| ext.to_s.sub(/\A\.?/, ".") }.to_set
+        end
+
+        @common_path = common_path(@dirs.keys)
+
+        @dtw = directories_to_watch
+        @missing = []
+
+        @updated = Concurrent::AtomicBoolean.new(false)
+        @mutex = Mutex.new
+
+        start
+        # inotify / FSEvents file descriptors are inherited on fork, so
+        # we need to reopen them otherwise only the parent or the child
+        # will be notified.
+        # FIXME: this callback is keeping a reference on the instance
+        @after_fork = ActiveSupport::ForkTracker.after_fork { start }
+      end
+
+      def finalizer
+        proc do
+          stop
+          ActiveSupport::ForkTracker.unregister(@after_fork)
+        end
+      end
+
+      def thread_safely
+        @mutex.synchronize do
+          yield self
+        end
+      end
+
+      def start
+        normalize_dirs!
+        @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
+        @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
+        @listener&.start
+
+        # Wait for the listener to be ready to avoid race conditions
+        # Unfortunately this isn't quite enough on macOS because the Darwin backend
+        # has an extra private thread we can't wait on.
+        @listener&.wait_for_state(:processing_events)
+      end
+
+      def stop
+        @listener&.stop
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      def restart?
+        @missing.any?(&:exist?)
+      end
+
+      def normalize_dirs!
+        @dirs.transform_keys! do |dir|
+          dir.exist? ? dir.realpath : dir
+        end
+      end
+
+      def changed(modified, added, removed)
+        unless @updated.true?
+          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
+        end
+      end
+
+      def watching?(file)
+        file = Pathname(file)
+
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = file.extname
+
+          file.dirname.ascend do |dir|
+            matching = @dirs[dir]
+
+            if matching && (matching.empty? || matching.include?(ext))
+              break true
+            elsif dir == @common_path || dir.root?
+              break false
+            end
+          end
+        end
+      end
+
+      def directories_to_watch
+        dtw = @dirs.keys | @files.map(&:dirname)
+        accounted_for = dtw.to_set + Gem.path.map { |path| Pathname(path) }
+        dtw.reject { |dir| dir.ascend.drop(1).any? { |parent| accounted_for.include?(parent) } }
+      end
+
+      def common_path(paths)
+        paths.map { |path| path.ascend.to_a }.reduce(&:&)&.first
+      end
+    end
+  end
+end

data/lib/active_support/execution_context/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ExecutionContext::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::ExecutionContext.clear
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::ExecutionContext.clear
+  end
+end

data/lib/active_support/execution_context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ExecutionContext # :nodoc:
+    @after_change_callbacks = []
+    class << self
+      def after_change(&block)
+        @after_change_callbacks << block
+      end
+
+      # Updates the execution context. If a block is given, it resets the provided keys to their
+      # previous value once the block exits.
+      def set(**options)
+        options.symbolize_keys!
+        keys = options.keys
+
+        store = self.store
+
+        previous_context = keys.zip(store.values_at(*keys)).to_h
+
+        store.merge!(options)
+        @after_change_callbacks.each(&:call)
+
+        if block_given?
+          begin
+            yield
+          ensure
+            store.merge!(previous_context)
+            @after_change_callbacks.each(&:call)
+          end
+        end
+      end
+
+      def []=(key, value)
+        store[key.to_sym] = value
+        @after_change_callbacks.each(&:call)
+      end
+
+      def to_h
+        store.dup
+      end
+
+      def clear
+        store.clear
+      end
+
+      private
+        def store
+          IsolatedExecutionState[:active_support_execution_context] ||= {}
+        end
+    end
+  end
+end

data/lib/active_support/execution_wrapper.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "active_support/error_reporter"
+require "active_support/callbacks"
+
+module ActiveSupport
+  class ExecutionWrapper
+    include ActiveSupport::Callbacks
+
+    Null = Object.new # :nodoc:
+    def Null.complete! # :nodoc:
+    end
+
+    define_callbacks :run
+    define_callbacks :complete
+
+    def self.to_run(*args, &block)
+      set_callback(:run, *args, &block)
+    end
+
+    def self.to_complete(*args, &block)
+      set_callback(:complete, *args, &block)
+    end
+
+    RunHook = Struct.new(:hook) do # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        hook_state[hook] = hook.run
+      end
+    end
+
+    CompleteHook = Struct.new(:hook) do # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        if hook_state.key?(hook)
+          hook.complete hook_state[hook]
+        end
+      end
+      alias after before
+    end
+
+    # Register an object to be invoked during both the +run+ and
+    # +complete+ steps.
+    #
+    # +hook.complete+ will be passed the value returned from +hook.run+,
+    # and will only be invoked if +run+ has previously been called.
+    # (Mostly, this means it won't be invoked if an exception occurs in
+    # a preceding +to_run+ block; all ordinary +to_complete+ blocks are
+    # invoked in that situation.)
+    def self.register_hook(hook, outer: false)
+      if outer
+        to_run RunHook.new(hook), prepend: true
+        to_complete :after, CompleteHook.new(hook)
+      else
+        to_run RunHook.new(hook)
+        to_complete CompleteHook.new(hook)
+      end
+    end
+
+    # Run this execution.
+    #
+    # Returns an instance, whose +complete!+ method *must* be invoked
+    # after the work has been performed.
+    #
+    # Where possible, prefer +wrap+.
+    def self.run!(reset: false)
+      if reset
+        lost_instance = IsolatedExecutionState.delete(active_key)
+        lost_instance&.complete!
+      else
+        return Null if active?
+      end
+
+      new.tap do |instance|
+        success = nil
+        begin
+          instance.run!
+          success = true
+        ensure
+          instance.complete! unless success
+        end
+      end
+    end
+
+    # Perform the work in the supplied block as an execution.
+    def self.wrap(source: "application.active_support")
+      return yield if active?
+
+      instance = run!
+      begin
+        yield
+      rescue => error
+        error_reporter&.report(error, handled: false, source: source)
+        raise
+      ensure
+        instance.complete!
+      end
+    end
+
+    def self.perform # :nodoc:
+      instance = new
+      instance.run
+      begin
+        yield
+      ensure
+        instance.complete
+      end
+    end
+
+    def self.error_reporter # :nodoc:
+      ActiveSupport.error_reporter
+    end
+
+    def self.active_key # :nodoc:
+      @active_key ||= :"active_execution_wrapper_#{object_id}"
+    end
+
+    def self.active? # :nodoc:
+      IsolatedExecutionState.key?(active_key)
+    end
+
+    def run! # :nodoc:
+      IsolatedExecutionState[self.class.active_key] = self
+      run
+    end
+
+    def run # :nodoc:
+      run_callbacks(:run)
+    end
+
+    # Complete this in-flight execution. This method *must* be called
+    # exactly once on the result of any call to +run!+.
+    #
+    # Where possible, prefer +wrap+.
+    def complete!
+      complete
+    ensure
+      IsolatedExecutionState.delete(self.class.active_key)
+    end
+
+    def complete # :nodoc:
+      run_callbacks(:complete)
+    end
+
+    private
+      def hook_state
+        @_hook_state ||= {}
+      end
+  end
+end

data/lib/active_support/executor/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Executor::TestHelper # :nodoc:
+  def run(...)
+    Rails.application.executor.perform { super }
+  end
+end

data/lib/active_support/executor.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "active_support/execution_wrapper"
+
+module ActiveSupport
+  class Executor < ExecutionWrapper
+  end
+end

data/lib/active_support/file_update_checker.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time/calculations"
+
+module ActiveSupport
+  # = \File Update Checker
+  #
+  # FileUpdateChecker specifies the API used by \Rails to watch files
+  # and control reloading. The API depends on four methods:
+  #
+  # * +initialize+ which expects two parameters and one block as
+  #   described below.
+  #
+  # * +updated?+ which returns a boolean if there were updates in
+  #   the filesystem or not.
+  #
+  # * +execute+ which executes the given block on initialization
+  #   and updates the latest watched files and timestamp.
+  #
+  # * +execute_if_updated+ which just executes the block if it was updated.
+  #
+  # After initialization, a call to +execute_if_updated+ must execute
+  # the block only if there was really a change in the filesystem.
+  #
+  # This class is used by \Rails to reload the I18n framework whenever
+  # they are changed upon a new request.
+  #
+  #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do
+  #     I18n.reload!
+  #   end
+  #
+  #   ActiveSupport::Reloader.to_prepare do
+  #     i18n_reloader.execute_if_updated
+  #   end
+  class FileUpdateChecker
+    # It accepts two parameters on initialization. The first is an array
+    # of files and the second is an optional hash of directories. The hash must
+    # have directories as keys and the value is an array of extensions to be
+    # watched under that directory.
+    #
+    # This method must also receive a block that will be called once a path
+    # changes. The array of files and list of directories cannot be changed
+    # after FileUpdateChecker has been initialized.
+    def initialize(files, dirs = {}, &block)
+      unless block
+        raise ArgumentError, "A block is required to initialize a FileUpdateChecker"
+      end
+
+      @files = files.freeze
+      @glob  = compile_glob(dirs)
+      @block = block
+
+      @watched    = nil
+      @updated_at = nil
+
+      @last_watched   = watched
+      @last_update_at = updated_at(@last_watched)
+    end
+
+    # Check if any of the entries were updated. If so, the watched and/or
+    # updated_at values are cached until the block is executed via +execute+
+    # or +execute_if_updated+.
+    def updated?
+      current_watched = watched
+      if @last_watched.size != current_watched.size
+        @watched = current_watched
+        true
+      else
+        current_updated_at = updated_at(current_watched)
+        if @last_update_at < current_updated_at
+          @watched    = current_watched
+          @updated_at = current_updated_at
+          true
+        else
+          false
+        end
+      end
+    end
+
+    # Executes the given block and updates the latest watched files and
+    # timestamp.
+    def execute
+      @last_watched   = watched
+      @last_update_at = updated_at(@last_watched)
+      @block.call
+    ensure
+      @watched = nil
+      @updated_at = nil
+    end
+
+    # Execute the block given if updated.
+    def execute_if_updated
+      if updated?
+        yield if block_given?
+        execute
+        true
+      else
+        false
+      end
+    end
+
+    private
+      def watched
+        @watched || begin
+          all = @files.select { |f| File.exist?(f) }
+          all.concat(Dir[@glob]) if @glob
+          all.tap(&:uniq!)
+        end
+      end
+
+      def updated_at(paths)
+        @updated_at || max_mtime(paths) || Time.at(0)
+      end
+
+      # This method returns the maximum mtime of the files in +paths+, or +nil+
+      # if the array is empty.
+      #
+      # Files with a mtime in the future are ignored. Such abnormal situation
+      # can happen for example if the user changes the clock by hand. It is
+      # healthy to consider this edge case because with mtimes in the future
+      # reloading is not triggered.
+      def max_mtime(paths)
+        time_now = Time.now
+        max_mtime = nil
+
+        # Time comparisons are performed with #compare_without_coercion because
+        # AS redefines these operators in a way that is much slower and does not
+        # bring any benefit in this particular code.
+        #
+        # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
+        paths.each do |path|
+          mtime = File.mtime(path)
+
+          next if time_now.compare_without_coercion(mtime) < 0
+
+          if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
+            max_mtime = mtime
+          end
+        end
+
+        max_mtime
+      end
+
+      def compile_glob(hash)
+        hash.freeze # Freeze so changes aren't accidentally pushed
+        return if hash.empty?
+
+        globs = hash.map do |key, value|
+          "#{escape(key)}/**/*#{compile_ext(value)}"
+        end
+        "{#{globs.join(",")}}"
+      end
+
+      def escape(key)
+        key.gsub(",", '\,')
+      end
+
+      def compile_ext(array)
+        array = Array(array)
+        return if array.empty?
+        ".{#{array.join(",")}}"
+      end
+  end
+end

data/lib/active_support/fork_tracker.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ForkTracker # :nodoc:
+    module CoreExt
+      def _fork
+        pid = super
+        if pid == 0
+          ForkTracker.after_fork_callback
+        end
+        pid
+      end
+    end
+
+    @pid = Process.pid
+    @callbacks = []
+
+    class << self
+      def after_fork_callback
+        new_pid = Process.pid
+        if @pid != new_pid
+          @callbacks.each(&:call)
+          @pid = new_pid
+        end
+      end
+
+      def hook!
+        ::Process.singleton_class.prepend(CoreExt)
+      end
+
+      def after_fork(&block)
+        @callbacks << block
+        block
+      end
+
+      def unregister(callback)
+        @callbacks.delete(callback)
+      end
+    end
+  end
+end
+
+ActiveSupport::ForkTracker.hook!

data/lib/active_support/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Returns the currently loaded version of Active Support as a +Gem::Version+.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha1"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_support/gzip.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
+
+module ActiveSupport
+  # = Active Support \Gzip
+  #
+  # A convenient wrapper for the zlib standard library that allows
+  # compression/decompression of strings with gzip.
+  #
+  #   gzip = ActiveSupport::Gzip.compress('compress me!')
+  #   # => "\x1F\x8B\b\x00o\x8D\xCDO\x00\x03K\xCE\xCF-(J-.V\xC8MU\x04\x00R>n\x83\f\x00\x00\x00"
+  #
+  #   ActiveSupport::Gzip.decompress(gzip)
+  #   # => "compress me!"
+  module Gzip
+    class Stream < StringIO
+      def initialize(*)
+        super
+        set_encoding "BINARY"
+      end
+      def close; rewind; end
+    end
+
+    # Decompresses a gzipped string.
+    def self.decompress(source)
+      Zlib::GzipReader.wrap(StringIO.new(source), &:read)
+    end
+
+    # Compresses a string using gzip.
+    def self.compress(source, level = Zlib::DEFAULT_COMPRESSION, strategy = Zlib::DEFAULT_STRATEGY)
+      output = Stream.new
+      gz = Zlib::GzipWriter.new(output, level, strategy)
+      gz.write(source)
+      gz.close
+      output.string
+    end
+  end
+end