filewatcher 1.0.0 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 025e651355a5bbbae353527112232253ee4f682d
-  data.tar.gz: 95ca7990a7e002768ac0a7a814a4129841efe3d6
+SHA256:
+  metadata.gz: cbf8702009840bc579d652246d0a0540b9ce7bcfc29ebf9d94995cf53c1343db
+  data.tar.gz: 4a2b253229620ae6ed2522a03d46105ce266161d116192615ce0bc3ecb396bf2
 SHA512:
-  metadata.gz: b8576d1ff169c063a664ae9c538c51ad079ccfae4a604e0c277b84df261dc438b25f912863e5bd9b2ae542bac48026ea8f5a9a0990ccb81265206751b6138a1a
-  data.tar.gz: 25b04df22331575a7ffbfce5c1acc5168c0ee58e9d15fa4d4f7f3dff309fe1382be5920c315015309217bbf108882d994777cda67376c511c1197d6840952e7e
+  metadata.gz: a711c6cfce133aad2892381de2804c4c3fd4f9405d280df85c2c1a496fceb8f77055559637728560ed96afb0cd4588b66a397b331e8006f416ea630501fb27d7
+  data.tar.gz: ba768df36f5fd263645dfd5421473bd5b54d71472b808fd279ea844d76e517584123314fd1af4d246f056ec088463fccb45106e71cc80404594af9fdfbd68b06

data/lib/filewatcher.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
+require 'logger'
 require_relative 'filewatcher/cycles'
+require_relative 'filewatcher/snapshots'
 
 # Simple file watcher. Detect changes in files and directories.
 #
-# Issues: Currently doesn't monitor changes in directorynames
+# Issues: Currently doesn't monitor changes in directory names
 class Filewatcher
   include Filewatcher::Cycles
+  include Filewatcher::Snapshots
 
-  attr_writer :interval
-
-  def update_spinner(label)
-    return unless @show_spinner
-    @spinner ||= %w[\\ | / -]
-    print "#{' ' * 30}\r#{label}  #{@spinner.rotate!.first}\r"
-  end
+  attr_accessor :interval
+  attr_reader :keep_watching
 
   def initialize(unexpanded_filenames, options = {})
     @unexpanded_filenames = unexpanded_filenames
@@ -22,37 +20,46 @@ class Filewatcher
     @keep_watching = false
     @pausing = false
     @immediate = options[:immediate]
-    @show_spinner = options[:spinner]
     @interval = options.fetch(:interval, 0.5)
-    @every = options[:every]
+    @logger = options.fetch(:logger, Logger.new($stdout, level: :info))
+
+    after_initialize unexpanded_filenames, options
   end
 
   def watch(&on_update)
-    trap('SIGINT') { return }
+    ## The set of available signals depends on the OS
+    ## Windows doesn't support `HUP` signal, for example
+    (%w[HUP INT TERM] & Signal.list.keys).each do |signal|
+      trap(signal) { exit }
+    end
+
     @on_update = on_update
     @keep_watching = true
-    yield('', '') if @immediate
+    yield({ '' => '' }) if @immediate
 
     main_cycle
 
-    @end_snapshot = mtime_snapshot
+    @end_snapshot = current_snapshot
     finalize(&on_update)
   end
 
   def pause
     @pausing = true
-    update_spinner('Initiating pause')
+
+    before_pause_sleep
+
     # Ensure we wait long enough to enter pause loop in #watch
     sleep @interval
   end
 
   def resume
-    if !@keep_watching || !@pausing
-      raise "Can't resume unless #watch and #pause were first called"
-    end
-    @last_snapshot = mtime_snapshot # resume with fresh snapshot
+    raise "Can't resume unless #watch and #pause were first called" if !@keep_watching || !@pausing
+
+    @last_snapshot = current_snapshot # resume with fresh snapshot
     @pausing = false
-    update_spinner('Resuming')
+
+    before_resume_sleep
+
     sleep @interval # Wait long enough to exit pause loop in #watch
   end
 
@@ -60,7 +67,9 @@ class Filewatcher
   # Used mainly in multi-threaded situations.
   def stop
     @keep_watching = false
-    update_spinner('Stopping')
+
+    after_stop
+
     nil
   end
 
@@ -68,56 +77,17 @@ class Filewatcher
   # current snapshot are dealt with
   def finalize(&on_update)
     on_update = @on_update unless block_given?
-    while filesystem_updated?(@end_snapshot || mtime_snapshot)
-      update_spinner('Finalizing')
+
+    while file_system_updated?(@end_snapshot || current_snapshot)
+      finalizing
       trigger_changes(on_update)
     end
-    @end_snapshot = nil
-  end
 
-  def last_found_filenames
-    last_snapshot.keys
+    @end_snapshot = nil
   end
 
   private
 
-  def last_snapshot
-    @last_snapshot ||= mtime_snapshot
-  end
-
-  # Takes a snapshot of the current status of watched files.
-  # (Allows avoidance of potential race condition during #finalize)
-  def mtime_snapshot
-    snapshot = {}
-    filenames = expand_directories(@unexpanded_filenames)
-
-    # Remove files in the exclude filenames list
-    filenames -= expand_directories(@unexpanded_excluded_filenames)
-
-    filenames.each do |filename|
-      mtime = File.exist?(filename) ? File.mtime(filename) : Time.new(0)
-      snapshot[filename] = mtime
-    end
-    snapshot
-  end
-
-  def filesystem_updated?(snapshot = mtime_snapshot)
-    @changes = {}
-
-    # rubocop:disable Perfomance/HashEachMethods
-    ## https://github.com/bbatsov/rubocop/issues/4732
-    (snapshot.to_a - last_snapshot.to_a).each do |file, _mtime|
-      @changes[file] = last_snapshot[file] ? :updated : :created
-    end
-
-    (last_snapshot.keys - snapshot.keys).each do |file|
-      @changes[file] = :deleted
-    end
-
-    @last_snapshot = snapshot
-    @changes.any?
-  end
-
   def expand_directories(patterns)
     patterns = Array(patterns) unless patterns.is_a? Array
     expanded_patterns = patterns.map do |pattern|
@@ -130,6 +100,30 @@ class Filewatcher
     expanded_patterns.uniq!
     expanded_patterns
   end
+
+  def debug(data)
+    @logger.debug "Thread ##{Thread.current.object_id} #{data}"
+  end
+
+  def after_initialize(*)
+    super if defined?(super)
+  end
+
+  def before_pause_sleep
+    super if defined?(super)
+  end
+
+  def before_resume_sleep
+    super if defined?(super)
+  end
+
+  def after_stop
+    super if defined?(super)
+  end
+
+  def finalizing
+    super if defined?(super)
+  end
 end
 
 # Require at end of file to not overwrite `Filewatcher` class

data/lib/filewatcher/cycles.rb

@@ -7,7 +7,7 @@ class Filewatcher
 
     def main_cycle
       while @keep_watching
-        @end_snapshot = mtime_snapshot if @pausing
+        @end_snapshot = current_snapshot if @pausing
 
         pausing_cycle
 
@@ -21,27 +21,36 @@ class Filewatcher
 
     def pausing_cycle
       while @keep_watching && @pausing
-        update_spinner('Pausing')
+        before_pausing_sleep
+
         sleep @interval
       end
     end
 
+    def before_pausing_sleep
+      super if defined?(super)
+    end
+
     def watching_cycle
-      while @keep_watching && !filesystem_updated? && !@pausing
-        update_spinner('Watching')
+      @last_snapshot ||= current_snapshot
+      loop do
+        before_watching_sleep
+
+        debug "#{__method__} sleep #{@interval}"
         sleep @interval
+        break if !@keep_watching || file_system_updated? || @pausing
       end
     end
 
+    def before_watching_sleep
+      super if defined?(super)
+    end
+
     def trigger_changes(on_update = @on_update)
-      thread = Thread.new do
-        changes = @every ? @changes : @changes.first(1)
-        changes.each do |filename, event|
-          on_update.call(filename, event)
-        end
-        @changes.clear
-      end
-      thread.join
+      debug __method__
+      on_update.call(@changes.dup) unless @changes.empty?
+      @changes.clear
+      debug '@changes cleared'
     end
   end
 end

data/lib/filewatcher/snapshot.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+class Filewatcher
+  # Class for snapshots of file system
+  class Snapshot
+    extend Forwardable
+    def_delegators :@data, :[], :each, :keys
+
+    def initialize(filenames)
+      @data = filenames.each_with_object({}) do |filename, data|
+        data[filename] = SnapshotFile.new(filename)
+      end
+    end
+
+    def -(other)
+      changes = {}
+
+      each do |filename, snapshot_file|
+        changes[filename] = snapshot_file - other[filename]
+      end
+
+      other.each do |filename, _snapshot_file|
+        changes[filename] = :deleted unless self[filename]
+      end
+
+      changes.reject! { |_filename, event| event.nil? }
+      changes
+    end
+
+    # Class for one file from snapshot
+    class SnapshotFile
+      STATS = %i[mtime].freeze
+
+      attr_reader(*STATS)
+
+      def initialize(filename)
+        @filename = filename
+        STATS.each do |stat|
+          time = File.public_send(stat, filename) if File.exist?(filename)
+          instance_variable_set :"@#{stat}", time || Time.new(0)
+        end
+      end
+
+      def -(other)
+        if other.nil?
+          :created
+        elsif other.mtime < mtime
+          :updated
+        end
+      end
+
+      def inspect
+        <<~OUTPUT
+          #<Filewatcher::Snapshot::SnapshotFile:#{object_id}
+            @filename=#{@filename.inspect}, mtime=#{mtime.strftime('%F %T.%9N').inspect}
+          >
+        OUTPUT
+      end
+    end
+
+    private_constant :SnapshotFile
+  end
+end

data/lib/filewatcher/snapshots.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'snapshot'
+
+# Helpers in Filewatcher class itself
+class Filewatcher
+  class << self
+    def system_stat(filename)
+      case Gem::Platform.local.os
+      when 'linux' then `stat --printf 'Modification: %y, Change: %z\n' #{filename}`
+      when 'darwin' then `stat #{filename}`
+      else 'Unknown OS for system `stat`'
+      end
+    end
+  end
+
+  # Module for snapshot logic inside Filewatcher
+  module Snapshots
+    def found_filenames
+      current_snapshot.keys
+    end
+
+    private
+
+    def watching_files
+      expand_directories(@unexpanded_filenames) - expand_directories(@unexpanded_excluded_filenames)
+    end
+
+    # Takes a snapshot of the current status of watched files.
+    # (Allows avoidance of potential race condition during #finalize)
+    def current_snapshot
+      Filewatcher::Snapshot.new(watching_files)
+    end
+
+    def file_mtime(filename)
+      return Time.new(0) unless File.exist?(filename)
+
+      result = File.mtime(filename)
+      if @logger.level <= Logger::DEBUG
+        debug "File.mtime = #{result.strftime('%F %T.%9N')}"
+        debug "stat #{filename}: #{self.class.system_stat(filename)}"
+      end
+      result
+    end
+
+    def file_system_updated?(snapshot = current_snapshot)
+      debug __method__
+
+      @changes = snapshot - @last_snapshot
+
+      @last_snapshot = snapshot
+
+      @changes.any?
+    end
+  end
+end

data/lib/filewatcher/spec_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+begin
+  require 'pry-byebug'
+rescue LoadError
+  nil
+end
+
+require_relative 'spec_helper/watch_run'
+
+class Filewatcher
+  ## Helper for common spec features between plugins
+  module SpecHelper
+    def logger
+      @logger ||= Logger.new($stdout, level: :debug)
+    end
+
+    def environment_specs_coefficients
+      @environment_specs_coefficients ||= {
+        -> { ENV['CI'] } => 1,
+        -> { RUBY_PLATFORM == 'java' } => 3,
+        -> { Gem::Platform.local.os == 'darwin' } => 1
+      }
+    end
+
+    def wait(seconds: 1, interval: 1, &block)
+      environment_specs_coefficients.each do |condition, coefficient|
+        next unless instance_exec(&condition)
+
+        interval *= coefficient
+        seconds *= coefficient
+      end
+
+      if block_given?
+        wait_with_block seconds, interval, &block
+      else
+        wait_without_block seconds
+      end
+    end
+
+    def wait_with_block(seconds, interval, &_block)
+      (seconds / interval).ceil.times do
+        break if yield
+
+        debug "sleep interval #{interval}"
+        sleep interval
+      end
+    end
+
+    def wait_without_block(seconds)
+      debug "sleep without intervals #{seconds}"
+      sleep seconds
+    end
+
+    def debug(string)
+      logger.debug "Thread ##{Thread.current.object_id} #{string}"
+    end
+
+    ## https://github.com/rubocop-hq/ruby-style-guide/issues/556#issuecomment-691274359
+    # rubocop:disable Style/ModuleFunction
+    extend self
+    # rubocop:enable Style/ModuleFunction
+  end
+end

data/lib/filewatcher/spec_helper/watch_run.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+class Filewatcher
+  module SpecHelper
+    ## Base class for Filewatcher runners in specs
+    class WatchRun
+      extend Forwardable
+
+      TMP_DIR = "#{Dir.getwd}/spec/tmp"
+
+      def_delegators Filewatcher::SpecHelper, :debug, :wait
+
+      attr_reader :filename
+
+      def initialize(filename:, action:, directory:)
+        @filename =
+          if filename.match? %r{^(/|~|[A-Z]:)} then filename
+          else File.join(TMP_DIR, filename)
+          end
+        @directory = directory
+        @action = action
+        debug "action = #{action}"
+      end
+
+      def start
+        debug 'start'
+        File.write(@filename, 'content1') unless @action == :create
+
+        wait seconds: 1
+      end
+
+      def run(make_changes_times: 1)
+        start
+
+        make_changes_times.times do
+          make_changes
+
+          wait seconds: 2
+        end
+
+        stop
+      end
+
+      def stop
+        debug 'stop'
+        FileUtils.rm_r(@filename) if File.exist?(@filename)
+      end
+
+      private
+
+      def make_changes
+        debug "make changes, @action = #{@action}, @filename = #{@filename}"
+
+        if @action == :delete
+          FileUtils.remove(@filename)
+        elsif @directory
+          FileUtils.mkdir_p(@filename)
+        else
+          ## There is no `File.write` because of strange difference in parallel `File.mtime`
+          ## https://cirrus-ci.com/task/6107605053472768?command=test#L497-L511
+          system "echo 'content2' > #{@filename}"
+          debug_file_mtime
+        end
+
+        wait seconds: 1
+      end
+
+      def debug_file_mtime
+        debug "stat #{@filename}: #{Filewatcher.system_stat(@filename)}"
+        debug "File.mtime = #{File.mtime(@filename).strftime('%F %T.%9N')}"
+      end
+    end
+  end
+end