filewatcher 0.5.4 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1530083e28860bdfe9ffd4cc1c754b6026e25814
-  data.tar.gz: d9fad06f13778bb85fbc6206e9975885cb83a874
+SHA256:
+  metadata.gz: 8bff81f17e2979e1f38b9a19ed820827b4f7856b018adab83f212cb7a9777011
+  data.tar.gz: 6ce4ec41d01b08e4be1839d7f4fc834a66403517b0430a458ccff814ef61fc23
 SHA512:
-  metadata.gz: 3f3044ce20143591b8c257ab09eab7c0a14b1058784020abea5653fb114ef61fa4f98e6813f61a1d7c825a54a3787b9d20416cd1086a9179524068550fbfcefa
-  data.tar.gz: c1409c73a378c5c0debc73725904a5f8260de6e828e5e93863f8f8018eeafbb907e3aa2d735fdc423818c80aec8a8207bd76857f088106d74162d9f877bb86eb
+  metadata.gz: 3d58c98c188d13e760d644964d25c21edbe8d863646825fe703f08e63b7ffd58b1a702fd284f7d66aa785a939c626a5d79ccc5aa4e6abd15b2e014490d9d467f
+  data.tar.gz: 6a66f86cc5a4357ddf0182fdf15088f6f1935430643c47e1caef509c13795cdb181d8433b213dcd76090188ca1782f5d94557c4ff59c9ed9d27a8584ca6ff6cd

data/lib/filewatcher.rb

@@ -1,189 +1,130 @@
-# coding: utf-8
-# Simple file watcher. Detect changes in files and directories.
-#
-# Issues: Currently doesn't monitor changes in directorynames
-class FileWatcher
+# frozen_string_literal: true
 
-  attr_accessor :filenames
+require 'logger'
+require_relative 'filewatcher/cycles'
+require_relative 'filewatcher/snapshots'
 
-  def self.VERSION
-    return '0.5.4'
-  end
+# Simple file watcher. Detect changes in files and directories.
+#
+# Issues: Currently doesn't monitor changes in directory names
+class Filewatcher
+  include Filewatcher::Cycles
+  include Filewatcher::Snapshots
 
-  def update_spinner(label)
-    return nil 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, *args)
-    if(args.first)
-      options = args.first
-    else
-      options = {}
-    end
+  def initialize(unexpanded_filenames, options = {})
     @unexpanded_filenames = unexpanded_filenames
     @unexpanded_excluded_filenames = options[:exclude]
-    @filenames = nil
-    @stored_update = nil
     @keep_watching = false
     @pausing = false
-    @last_snapshot = mtime_snapshot
-    @end_snapshot = nil
-    @dontwait = options[:dontwait]
-    @show_spinner = options[:spinner]
-    @interval = options[:interval]
+    @immediate = options[:immediate]
+    @interval = options.fetch(:interval, 0.5)
+    @logger = options.fetch(:logger, Logger.new($stdout, level: :info))
+
+    after_initialize unexpanded_filenames, options
   end
 
-  def watch(sleep=0.5, &on_update)
-    trap("SIGINT") {return }
-    @sleep = sleep
-    if(@interval and @interval > 0)
-      @sleep = @interval
+  def watch(&on_update)
+    ## 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
-    @stored_update = on_update
+
+    @on_update = on_update
     @keep_watching = true
-    if(@dontwait)
-      yield '',''
-    end
-    while @keep_watching
-      @end_snapshot = mtime_snapshot if @pausing
-      while @keep_watching && @pausing
-        update_spinner('Pausing')
-        Kernel.sleep @sleep
-      end
-      while @keep_watching && !filesystem_updated? && !@pausing
-        update_spinner('Watching')
-        Kernel.sleep @sleep
-      end
-      # test and null @updated_file to prevent yielding the last
-      # file twice if @keep_watching has just been set to false
-      yield @updated_file, @event if @updated_file
-      @updated_file = nil
-    end
-    @end_snapshot = mtime_snapshot
+    yield({ '' => '' }) if @immediate
+
+    main_cycle
+
+    @end_snapshot = current_snapshot
     finalize(&on_update)
   end
 
   def pause
     @pausing = true
-    update_spinner('Initiating pause')
-    Kernel.sleep @sleep # Ensure we wait long enough to enter pause loop
-                        # in #watch
+
+    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')
-    Kernel.sleep @sleep # Wait long enough to exit pause loop in #watch
+
+    before_resume_sleep
+
+    sleep @interval # Wait long enough to exit pause loop in #watch
   end
 
   # Ends the watch, allowing any remaining changes to be finalized.
   # Used mainly in multi-threaded situations.
   def stop
     @keep_watching = false
-    update_spinner('Stopping')
-    return nil
+
+    after_stop
+
+    nil
   end
 
   # Calls the update block repeatedly until all changes in the
   # current snapshot are dealt with
   def finalize(&on_update)
-    on_update = @stored_update if !block_given?
-    snapshot = @end_snapshot ? @end_snapshot : mtime_snapshot
-    while filesystem_updated?(snapshot)
-      update_spinner('Finalizing')
-      on_update.call(@updated_file, @event)
-    end
-    @end_snapshot =nil
-    return nil
-  end
+    on_update = @on_update unless block_given?
 
-  # 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)
-
-    if(@unexpanded_excluded_filenames != nil and @unexpanded_excluded_filenames.size > 0)
-      # Remove files in the exclude filenames list
-      @filtered_filenames = []
-      @excluded_filenames = expand_directories(@unexpanded_excluded_filenames)
-      @filenames.each do |filename|
-        if(not(@excluded_filenames.include?(filename)))
-          @filtered_filenames << filename
-        end
-      end
-      @filenames = @filtered_filenames
+    while file_system_updated?(@end_snapshot || current_snapshot)
+      finalizing
+      trigger_changes(on_update)
     end
 
-    @filenames.each do |filename|
-      mtime = File.exist?(filename) ? File.stat(filename).mtime : Time.new(0)
-      snapshot[filename] = mtime
-    end
-    return snapshot
+    @end_snapshot = nil
   end
 
-  def filesystem_updated?(snapshot_to_use = nil)
-    snapshot = snapshot_to_use ? snapshot_to_use : mtime_snapshot
-    forward_changes = snapshot.to_a - @last_snapshot.to_a
-
-    forward_changes.each do |file,mtime|
-      @updated_file = file
-      unless @last_snapshot.fetch(@updated_file,false)
-        @last_snapshot[file] = mtime
-        @event = :new
-        return true
-      else
-        @last_snapshot[file] = mtime
-        @event = :changed
-        return true
-      end
-    end
+  private
 
-    backward_changes = @last_snapshot.to_a - snapshot.to_a
-    forward_names = forward_changes.map{|change| change.first}
-    backward_changes.reject!{|f,m| forward_names.include?(f)}
-    backward_changes.each do |file,mtime|
-      @updated_file = file
-      @last_snapshot.delete(file)
-      @event = :delete
-      return true
+  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
-    return false
+    expanded_patterns.flatten!
+    expanded_patterns.uniq!
+    expanded_patterns
   end
 
-  def last_found_filenames
-    @last_snapshot.keys
+  def debug(data)
+    @logger.debug "Thread ##{Thread.current.object_id} #{data}"
   end
 
-  def expand_directories(patterns)
-    if(!patterns.kind_of?Array)
-      patterns = [patterns]
-    end
-    patterns.map { |it| Dir[fulldepth(expand_path(it))] }.flatten.uniq
+  def after_initialize(*)
+    super if defined?(super)
   end
 
-  private
+  def before_pause_sleep
+    super if defined?(super)
+  end
 
-  def fulldepth(pattern)
-    if File.directory? pattern
-      "#{pattern}/**/*"
-    else
-      pattern
-    end
+  def before_resume_sleep
+    super if defined?(super)
   end
 
-  def expand_path(pattern)
-    if pattern.start_with?('~')
-      File.expand_path(pattern)
-    else
-      pattern
-    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
+require_relative 'filewatcher/version'

data/lib/filewatcher/cycles.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class Filewatcher
+  # Module for all cycles in `Filewatcher#watch`
+  module Cycles
+    private
+
+    def main_cycle
+      while @keep_watching
+        @end_snapshot = current_snapshot if @pausing
+
+        pausing_cycle
+
+        watching_cycle
+
+        # test and clear @changes to prevent yielding the last
+        # changes twice if @keep_watching has just been set to false
+        trigger_changes
+      end
+    end
+
+    def pausing_cycle
+      while @keep_watching && @pausing
+        before_pausing_sleep
+
+        sleep @interval
+      end
+    end
+
+    def before_pausing_sleep
+      super if defined?(super)
+    end
+
+    def watching_cycle
+      @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)
+      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