activesupport 5.0.0 → 6.1.0

data/lib/active_support/evented_file_update_checker.rb

@@ -1,6 +1,10 @@
-require 'set'
-require 'pathname'
-require 'concurrent/atomic/atomic_boolean'
+# frozen_string_literal: true
+
+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.
@@ -17,7 +21,7 @@ module ActiveSupport
   #
   # Example:
   #
-  #     checker = EventedFileUpdateChecker.new(["/tmp/foo"], -> { puts "changed" })
+  #     checker = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
   #     checker.updated?
   #     # => false
   #     checker.execute_if_updated
@@ -32,48 +36,26 @@ module ActiveSupport
   #
   class EventedFileUpdateChecker #:nodoc: all
     def initialize(files, dirs = {}, &block)
-      @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) }
+      unless block
+        raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"
       end
 
-      @block      = block
-      @updated    = Concurrent::AtomicBoolean.new(false)
-      @lcsp       = @ph.longest_common_subpath(@dirs.keys)
-      @pid        = Process.pid
-      @boot_mutex = Mutex.new
-
-      if (@dtw = directories_to_watch).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
-          begin
-            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
-      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
+      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
 
@@ -85,110 +67,104 @@ module ActiveSupport
       end
     end
 
-    private
-      def boot!
-        Listen.to(*@dtw, &method(:changed)).start
-      end
+    class Core
+      attr_reader :updated
 
-      def changed(modified, added, removed)
-        unless updated?
-          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
+      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
-      end
 
-      def watching?(file)
-        file = @ph.xpath(file)
+        @common_path = common_path(@dirs.keys)
 
-        if @files.member?(file)
-          true
-        elsif file.directory?
-          false
-        else
-          ext = @ph.normalize_extension(file.extname)
+        @dtw = directories_to_watch
+        @missing = []
 
-          file.dirname.ascend do |dir|
-            if @dirs.fetch(dir, []).include?(ext)
-              break true
-            elsif dir == @lcsp || dir.root?
-              break false
-            end
-          end
+        @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
 
-      def directories_to_watch
-        dtw = (@files + @dirs.keys).map { |f| @ph.existing_parent(f) }
-        dtw.compact!
-        dtw.uniq!
+      def thread_safely
+        @mutex.synchronize do
+          yield self
+        end
+      end
 
-        @ph.filter_out_descendants(dtw)
+      def start
+        normalize_dirs!
+        @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
+        @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
+        @listener&.start
       end
 
-    class PathHelper
-      def xpath(path)
-        Pathname.new(path).expand_path
+      def stop
+        @listener&.stop
       end
 
-      def normalize_extension(ext)
-        ext.to_s.sub(/\A\./, '')
+      def restart
+        stop
+        start
       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
+      def restart?
+        @missing.any?(&:exist?)
+      end
 
-        lcsp
+      def normalize_dirs!
+        @dirs.transform_keys! do |dir|
+          dir.exist? ? dir.realpath : dir
+        end
       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?
+      def changed(modified, added, removed)
+        unless @updated.true?
+          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
         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
+      def watching?(file)
+        file = Pathname(file)
 
-        dirs_sorted_by_nparts = dirs.sort_by { |dir| dir.each_filename.to_a.length }
-        descendants = []
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = file.extname
 
-        until dirs_sorted_by_nparts.empty?
-          dir = dirs_sorted_by_nparts.shift
+          file.dirname.ascend do |dir|
+            matching = @dirs[dir]
 
-          dirs_sorted_by_nparts.reject! do |possible_descendant|
-            ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
+            if matching && (matching.empty? || matching.include?(ext))
+              break true
+            elsif dir == @common_path || dir.root?
+              break false
+            end
           end
         end
-
-        # Array#- preserves order.
-        dirs - descendants
       end
 
-      private
+      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 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_wrapper.rb

@@ -1,4 +1,7 @@
-require 'active_support/callbacks'
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+require "concurrent/hash"
 
 module ActiveSupport
   class ExecutionWrapper
@@ -19,6 +22,23 @@ module ActiveSupport
       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.
     #
@@ -29,19 +49,11 @@ module ActiveSupport
     # invoked in that situation.)
     def self.register_hook(hook, outer: false)
       if outer
-        run_args = [prepend: true]
-        complete_args = [:after]
+        to_run RunHook.new(hook), prepend: true
+        to_complete :after, CompleteHook.new(hook)
       else
-        run_args = complete_args = []
-      end
-
-      to_run(*run_args) do
-        hook_state[hook] = hook.run
-      end
-      to_complete(*complete_args) do
-        if hook_state.key?(hook)
-          hook.complete hook_state[hook]
-        end
+        to_run RunHook.new(hook)
+        to_complete CompleteHook.new(hook)
       end
     end
 

data/lib/active_support/executor.rb

@@ -1,4 +1,6 @@
-require 'active_support/execution_wrapper'
+# frozen_string_literal: true
+
+require "active_support/execution_wrapper"
 
 module ActiveSupport
   class Executor < ExecutionWrapper

data/lib/active_support/file_update_checker.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/time/calculations'
+# frozen_string_literal: true
+
+require "active_support/core_ext/time/calculations"
 
 module ActiveSupport
   # FileUpdateChecker specifies the API used by Rails to watch files
@@ -38,6 +40,10 @@ module ActiveSupport
     # 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
@@ -92,66 +98,65 @@ module ActiveSupport
     end
 
     private
-
-    def watched
-      @watched || begin
-        all = @files.select { |f| File.exist?(f) }
-        all.concat(Dir[@glob]) if @glob
-        all
+      def watched
+        @watched || begin
+          all = @files.select { |f| File.exist?(f) }
+          all.concat(Dir[@glob]) if @glob
+          all
+        end
       end
-    end
 
-    def updated_at(paths)
-      @updated_at || max_mtime(paths) || Time.at(0)
-    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.
+      # This method returns the maximum mtime of the files in +paths+, or +nil+
+      # if the array is empty.
       #
-      # 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
+      # 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
-      end
 
-      max_mtime
-    end
+        max_mtime
+      end
 
-    def compile_glob(hash)
-      hash.freeze # Freeze so changes aren't accidentally pushed
-      return if hash.empty?
+      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)}"
+        globs = hash.map do |key, value|
+          "#{escape(key)}/**/*#{compile_ext(value)}"
+        end
+        "{#{globs.join(",")}}"
       end
-      "{#{globs.join(",")}}"
-    end
 
-    def escape(key)
-      key.gsub(',','\,')
-    end
+      def escape(key)
+        key.gsub(",", '\,')
+      end
 
-    def compile_ext(array)
-      array = Array(array)
-      return if array.empty?
-      ".{#{array.join(",")}}"
-    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,62 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ForkTracker # :nodoc:
+    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
+        def fork(*)
+          super
+        end
+    end
+
+    @pid = Process.pid
+    @callbacks = []
+
+    class << self
+      def check!
+        if @pid != Process.pid
+          @callbacks.each(&:call)
+          @pid = Process.pid
+        end
+      end
+
+      def hook!
+        if Process.respond_to?(:fork)
+          ::Object.prepend(CoreExtPrivate)
+          ::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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   # Returns the version of the currently loaded Active Support as a <tt>Gem::Version</tt>.
   def self.gem_version
@@ -5,8 +7,8 @@ module ActiveSupport
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 0
+    MAJOR = 6
+    MINOR = 1
     TINY  = 0
     PRE   = nil
 

data/lib/active_support/gzip.rb

@@ -1,5 +1,7 @@
-require 'zlib'
-require 'stringio'
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
 
 module ActiveSupport
   # A convenient wrapper for the zlib standard library that allows
@@ -9,7 +11,7 @@ module ActiveSupport
   #   # => "\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!" 
+  #   # => "compress me!"
   module Gzip
     class Stream < StringIO
       def initialize(*)
@@ -21,11 +23,11 @@ module ActiveSupport
 
     # Decompresses a gzipped string.
     def self.decompress(source)
-      Zlib::GzipReader.new(StringIO.new(source)).read
+      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)
+    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)