activesupport 6.0.6 → 7.0.1

data/lib/active_support/evented_file_update_checker.rb

@@ -3,6 +3,8 @@
 require "set"
 require "pathname"
 require "concurrent/atomic/atomic_boolean"
+require "listen"
+require "active_support/fork_tracker"
 
 module ActiveSupport
   # Allows you to "listen" to changes in a file system.
@@ -32,68 +34,28 @@ module ActiveSupport
   #     checker.execute_if_updated
   #     # => "changed"
   #
-  class EventedFileUpdateChecker #:nodoc: all
+  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!
+      @block = block
+      @core = Core.new(files, dirs)
+      ObjectSpace.define_finalizer(self, @core.finalizer)
     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
+      if @core.restart?
+        @core.thread_safely(&:restart)
+        @core.updated.make_true
       end
 
-      @updated.true?
+      @core.updated.true?
     end
 
     def execute
-      @updated.make_false
+      @core.updated.make_false
       @block.call
     end
 
@@ -105,17 +67,59 @@ module ActiveSupport
       end
     end
 
-    private
-      def boot!
-        normalize_dirs!
+    class Core
+      attr_reader :updated
+
+      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
+        @after_fork = ActiveSupport::ForkTracker.after_fork { start }
+      end
+
+      def finalizer
+        proc do
+          stop
+          ActiveSupport::ForkTracker.unregister(@after_fork)
+        end
+      end
 
-        unless @dtw.empty?
-          Listen.to(*@dtw, &method(:changed)).start
+      def thread_safely
+        @mutex.synchronize do
+          yield self
         end
       end
 
-      def shutdown!
-        Listen.stop
+      def start
+        normalize_dirs!
+        @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
+        @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
+        @listener&.start
+      end
+
+      def stop
+        @listener&.stop
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      def restart?
+        @missing.any?(&:exist?)
       end
 
       def normalize_dirs!
@@ -125,27 +129,27 @@ module ActiveSupport
       end
 
       def changed(modified, added, removed)
-        unless updated?
+        unless @updated.true?
           @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
         end
       end
 
       def watching?(file)
-        file = @ph.xpath(file)
+        file = Pathname(file)
 
         if @files.member?(file)
           true
         elsif file.directory?
           false
         else
-          ext = @ph.normalize_extension(file.extname)
+          ext = file.extname
 
           file.dirname.ascend do |dir|
             matching = @dirs[dir]
 
             if matching && (matching.empty? || matching.include?(ext))
               break true
-            elsif dir == @lcsp || dir.root?
+            elsif dir == @common_path || dir.root?
               break false
             end
           end
@@ -153,82 +157,14 @@ module ActiveSupport
       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)
+        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
 
-      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
+      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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/error_reporter"
 require "active_support/callbacks"
 require "concurrent/hash"
 
@@ -63,21 +64,18 @@ module ActiveSupport
     # after the work has been performed.
     #
     # Where possible, prefer +wrap+.
-    def self.run!(reset: false)
-      if reset
-        lost_instance = active.delete(Thread.current)
-        lost_instance&.complete!
+    def self.run!
+      if active?
+        Null
       else
-        return Null if active?
-      end
-
-      new.tap do |instance|
-        success = nil
-        begin
-          instance.run!
-          success = true
-        ensure
-          instance.complete! unless success
+        new.tap do |instance|
+          success = nil
+          begin
+            instance.run!
+            success = true
+          ensure
+            instance.complete! unless success
+          end
         end
       end
     end
@@ -89,15 +87,32 @@ module ActiveSupport
       instance = run!
       begin
         yield
+      rescue => error
+        error_reporter.report(error, handled: false)
+        raise
       ensure
         instance.complete!
       end
     end
 
+    def self.perform # :nodoc:
+      instance = new
+      instance.run
+      begin
+        yield
+      ensure
+        instance.complete
+      end
+    end
+
     class << self # :nodoc:
       attr_accessor :active
     end
 
+    def self.error_reporter
+      @error_reporter ||= ActiveSupport::ErrorReporter.new
+    end
+
     def self.inherited(other) # :nodoc:
       super
       other.active = Concurrent::Hash.new
@@ -106,11 +121,15 @@ module ActiveSupport
     self.active = Concurrent::Hash.new
 
     def self.active? # :nodoc:
-      @active.key?(Thread.current)
+      @active[IsolatedExecutionState.unique_id]
     end
 
     def run! # :nodoc:
-      self.class.active[Thread.current] = self
+      self.class.active[IsolatedExecutionState.unique_id] = true
+      run
+    end
+
+    def run # :nodoc:
       run_callbacks(:run)
     end
 
@@ -119,9 +138,13 @@ module ActiveSupport
     #
     # Where possible, prefer +wrap+.
     def complete!
-      run_callbacks(:complete)
+      complete
     ensure
-      self.class.active.delete Thread.current
+      self.class.active.delete(IsolatedExecutionState.unique_id)
+    end
+
+    def complete # :nodoc:
+      run_callbacks(:complete)
     end
 
     private

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/fork_tracker.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ForkTracker # :nodoc:
+    module ModernCoreExt
+      def _fork
+        pid = super
+        if pid == 0
+          ForkTracker.check!
+        end
+        pid
+      end
+    end
+
+    module CoreExt
+      def fork(...)
+        if block_given?
+          super do
+            ForkTracker.check!
+            yield
+          end
+        else
+          unless pid = super
+            ForkTracker.check!
+          end
+          pid
+        end
+      end
+    end
+
+    module CoreExtPrivate
+      include CoreExt
+      private :fork
+    end
+
+    @pid = Process.pid
+    @callbacks = []
+
+    class << self
+      def check!
+        new_pid = Process.pid
+        if @pid != new_pid
+          @callbacks.each(&:call)
+          @pid = new_pid
+        end
+      end
+
+      def hook!
+        if Process.respond_to?(:_fork) # Ruby 3.1+
+          ::Process.singleton_class.prepend(ModernCoreExt)
+        elsif Process.respond_to?(:fork)
+          ::Object.prepend(CoreExtPrivate) if RUBY_VERSION < "3.0"
+          ::Kernel.prepend(CoreExtPrivate)
+          ::Kernel.singleton_class.prepend(CoreExt)
+          ::Process.singleton_class.prepend(CoreExt)
+        end
+      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

@@ -7,9 +7,9 @@ module ActiveSupport
   end
 
   module VERSION
-    MAJOR = 6
+    MAJOR = 7
     MINOR = 0
-    TINY  = 6
+    TINY  = 1
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")