filewatcher 1.1.0 → 2.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ed73f2615aeb5418438bb443abc274bc2cd8279f
-  data.tar.gz: 716e8b582f81531d486c1a281149da1702a044b7
+SHA256:
+  metadata.gz: 5e9ecdeee0c20df3055e1078a67e8194040361fbcea9f1c633f2b33a8177f250
+  data.tar.gz: ba5abe65b765b0cc4c4630aae0cf1e0751c7ea4dec5f39911a9de9510fff7e9e
 SHA512:
-  metadata.gz: b37524eaae72f8eaaad40766e4e1793ec5766ebe7dd454e310eb98ba54745c59ecbc8358ea2045e335d242c84d6e48ef5bc1d0718b75546af481bd221f25c5d9
-  data.tar.gz: 50690825a35a747dce1491d7f3f77a2edf135797551ca625cdeeafb08efd31caada6e982de54fde6bdad88d4ae934b92bb66d29605a7d74e181bc5d059f9d367
+  metadata.gz: 287d42ea2fb239be62a4a0701f5b84440c409b6dc93c3b8caf5a5c8c87958ab12f4885e146e679f988dc2d2ef9c7d47d77be79ce4b8dd6d0ea97d71d63de9116
+  data.tar.gz: 2a296164258b091771802bbeb7d33690160e235220d30644743abe441d7801259dcad5bcd4216655c1e57549b9052edb45f1b1440a23ba1d84e4981f278a4e90

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,9 +29,10 @@ 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)
@@ -37,28 +44,31 @@ class Filewatcher
 
     @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
 
@@ -66,7 +76,9 @@ class Filewatcher
   # Used mainly in multi-threaded situations.
   def stop
     @keep_watching = false
-    update_spinner('Stopping')
+
+    after_stop
+
     nil
   end
 
@@ -74,65 +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 = {}
-
-    (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,47 @@
+# frozen_string_literal: true
+
+require_relative 'snapshot'
+
+# Helpers in Filewatcher class itself
+class Filewatcher
+  # 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,84 @@
+# 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
+    module_function
+
+    def logger
+      @logger ||= Logger.new($stdout, level: :debug)
+    end
+
+    def environment_specs_coefficients
+      @environment_specs_coefficients ||= {
+        -> { ENV['CI'] } => 1,
+        -> { RUBY_PLATFORM == 'java' } => 1,
+        -> { 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
+
+    def system_stat(filename)
+      case (host_os = RbConfig::CONFIG['host_os'])
+      when 'linux'
+        `stat --printf 'Modification: %y, Change: %z\n' #{filename}`
+      when /darwin\d*/
+        `stat #{filename}`
+      when *Gem::WIN_PATTERNS
+        system_stat_windows filename
+      else
+        "Unknown OS `#{host_os}` for system's `stat` command"
+      end
+    end
+
+    def system_stat_windows(filename)
+      filename = filename.gsub('/', '\\\\\\')
+      properties = 'CreationDate,InstallDate,LastModified,LastAccessed'
+      command = "wmic datafile where Name=\"#{filename}\" get #{properties}"
+      # debug command
+      `#{command}`
+    end
+  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, :system_stat
+
+      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}: #{system_stat(@filename)}"
+        debug "File.mtime = #{File.mtime(@filename).strftime('%F %T.%9N')}"
+      end
+    end
+  end
+end