filewatcher 1.0.1 → 2.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9221be161e73cc2f85ea6f9706a2e558c31ff314664bc31817e9715439a31927
-  data.tar.gz: bae2bc1ba2f5b88693fe1c8093b135652885094c69adc3da51193916ada96b44
+  metadata.gz: e1058d188f32d31bdf63775a8ff6655e64de608669630ef775c0e4975d196421
+  data.tar.gz: 57406a8b0be947051f295de3d6208faaf4ec60e432edc22a71d1e3b22fb58415
 SHA512:
-  metadata.gz: 0aec2e10e03aad69fd0e4ccda0a6f488efc7c908abe31640319971dda6ed71ca8873588d87693f91309d13ac996bb62a952e3c7430c41b462d663e0064185e8e
-  data.tar.gz: ebf1581b4e3e56c77c4a18867ce55d2cb9a6fbf97d7804da305192dd9622a39d9b16cfe1392dd880c6dd1c43f47539a66a10f61956de7fad0202f2c43222b64d
+  metadata.gz: d930968943fd907aad26eb150de20fa8d2681223dad1f516f9a27c2c096893bacaa8decd0e4646753f529dbec38bba32dd1b6951b442e2df69f6a01f943116fc
+  data.tar.gz: cc8919f9f7036cb7599b22589e5b6abadd7b2674f502eae3e9c70c3e29b72d222356f5569244b63b1524dfd64430fc8617283b1bc0f565fffc91b5299b85980e

data/lib/filewatcher.rb

@@ -1,20 +1,26 @@
 # 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_accessor :interval
   attr_reader :keep_watching
 
-  def update_spinner(label)
-    return unless @show_spinner
-    @spinner ||= %w[\\ | / -]
-    print "#{' ' * 30}\r#{label}  #{@spinner.rotate!.first}\r"
+  class << self
+    def print_version
+      system 'ruby -v'
+      puts "Filewatcher #{self::VERSION}"
+
+      super if defined? super
+    end
   end
 
   def initialize(unexpanded_filenames, options = {})
@@ -23,37 +29,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)
-    %w[HUP INT TERM].each { |signal| trap(signal) { exit } }
+    ## 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
 
@@ -61,7 +76,9 @@ class Filewatcher
   # Used mainly in multi-threaded situations.
   def stop
     @keep_watching = false
-    update_spinner('Stopping')
+
+    after_stop
+
     nil
   end
 
@@ -69,67 +86,39 @@ 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
+  def debug(data)
+    @logger.debug "Thread ##{Thread.current.object_id} #{data}"
   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
+  def after_initialize(*)
+    super if defined?(super)
   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
+  def before_pause_sleep
+    super if defined?(super)
+  end
 
-    (last_snapshot.keys - snapshot.keys).each do |file|
-      @changes[file] = :deleted
-    end
+  def before_resume_sleep
+    super if defined?(super)
+  end
 
-    @last_snapshot = snapshot
-    @changes.any?
+  def after_stop
+    super if defined?(super)
   end
 
-  def expand_directories(patterns)
-    patterns = Array(patterns) unless patterns.is_a? Array
-    expanded_patterns = patterns.map do |pattern|
-      pattern = File.expand_path(pattern)
-      Dir[
-        File.directory?(pattern) ? File.join(pattern, '**', '*') : pattern
-      ]
-    end
-    expanded_patterns.flatten!
-    expanded_patterns.uniq!
-    expanded_patterns
+  def finalizing
+    super if defined?(super)
   end
 end
 

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,64 @@
+# 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.tap(&:compact!)
+    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,57 @@
+# 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
+
+    # Takes a snapshot of the current status of watched files.
+    # (Allows avoidance of potential race condition during #finalize)
+    def current_snapshot
+      Filewatcher::Snapshot.new(
+        expand_directories(@unexpanded_filenames) -
+          expand_directories(@unexpanded_excluded_filenames)
+      )
+    end
+
+    def expand_directories(patterns)
+      patterns = Array(patterns) unless patterns.is_a? Array
+      expanded_patterns = patterns.map do |pattern|
+        pattern = File.expand_path(pattern)
+        Dir[
+          File.directory?(pattern) ? File.join(pattern, '**', '*') : pattern
+        ]
+      end
+      expanded_patterns.flatten!
+      expanded_patterns.uniq!
+      expanded_patterns
+    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
+        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