filewatcher 0.5.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1530083e28860bdfe9ffd4cc1c754b6026e25814
-  data.tar.gz: d9fad06f13778bb85fbc6206e9975885cb83a874
+  metadata.gz: 025e651355a5bbbae353527112232253ee4f682d
+  data.tar.gz: 95ca7990a7e002768ac0a7a814a4129841efe3d6
 SHA512:
-  metadata.gz: 3f3044ce20143591b8c257ab09eab7c0a14b1058784020abea5653fb114ef61fa4f98e6813f61a1d7c825a54a3787b9d20416cd1086a9179524068550fbfcefa
-  data.tar.gz: c1409c73a378c5c0debc73725904a5f8260de6e828e5e93863f8f8018eeafbb907e3aa2d735fdc423818c80aec8a8207bd76857f088106d74162d9f877bb86eb
+  metadata.gz: b8576d1ff169c063a664ae9c538c51ad079ccfae4a604e0c277b84df261dc438b25f912863e5bd9b2ae542bac48026ea8f5a9a0990ccb81265206751b6138a1a
+  data.tar.gz: 25b04df22331575a7ffbfce5c1acc5168c0ee58e9d15fa4d4f7f3dff309fe1382be5920c315015309217bbf108882d994777cda67376c511c1197d6840952e7e

data/bin/banner.txt

@@ -0,0 +1,17 @@
+Filewatcher scans the filesystem and executes shell commands when files changes.
+
+Usage:
+   filewatcher [--restart] '<filenames or patterns>' '<shell command>'
+Where
+   filename: filename(s) to scan.
+   shell command: shell command to execute when file changes on disk.
+
+Examples:
+   filewatcher "myfile" "echo 'myfile has changed'"
+   filewatcher '*.rb' 'ruby $FILENAME'
+   filewatcher '**/*.rb' 'ruby $FILENAME' # Watch subdirectories
+
+Other available environment variables are BASENAME, ABSOLUTE_FILENAME,
+RELATIVE_FILENAME, EVENT and DIRNAME.
+
+Options:

data/bin/filewatcher

@@ -1,88 +1,75 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'filewatcher'
+# frozen_string_literal: true
+
+require_relative '../lib/filewatcher'
+require_relative '../lib/filewatcher/env'
+require_relative '../lib/filewatcher/runner'
+require_relative '../lib/filewatcher/version'
 require 'trollop'
-require 'pathname'
 require 'thread'
 
-options = Trollop::options do
-  version "filewatcher, version #{FileWatcher.VERSION} by Thomas Flemming 2016"
-  banner <<-EOS
-Filewatcher scans the filesystem and executes shell commands when files changes.
-
-Usage:
-   filewatcher [--restart] '<filenames or patterns>' '<shell command>'
-Where
-   filename: filename(s) to scan.
-   shell command: shell command to execute when file changes on disk.
-
-Examples:
-   filewatcher "myfile" "echo 'myfile has changed'"
-   filewatcher '*.rb' 'ruby $FILENAME'
-   filewatcher '**/*.rb' 'ruby $FILENAME' # Watch subdirectories
-
-Other available environment variables are BASENAME, ABSOLUTE_FILENAME,
-RELATIVE_FILENAME, EVENT and DIRNAME.
-
-Options:
-EOS
-
-  opt :dontwait, "Do not wait for filesystem updates before running", :short => 'd', :type => :boolean, :default => false
-  opt :daemon, "Run in the background as system daemon.", :short => 'D', :type => :boolean, :default => false
-  opt :restart, "Restart process when filesystem is updated", :short => 'r', :type => :boolean, :default => false
-  opt :list, "Print name of files being watched"
-  opt :exec, "Execute file as a script when file is updated.", :short => 'e', :type => :boolean, :default => false
-  opt :include, "Include files", :type => :string, :default => "*"
-  opt :exclude, "Exclude file(s) matching", :type => :string, :default => ""
-  opt :interval, "Interval to scan filesystem.", :short => 'i', :type => :float, :default => 0.5
-  opt :spinner, "Show an ascii spinner", :short => 's', :type => :boolean, :default => false
+options = Trollop.options do
+  version "filewatcher, version #{Filewatcher::VERSION} by Thomas Flemming 2016"
+  banner File.read File.join(__dir__, 'banner.txt')
+
+  opt :immediate, 'Immediately execute a command',
+      short: 'I', type: :boolean, default: false
+  opt :every, 'Run command for every updated file in one filesystem check',
+      short: 'E', type: :boolean, default: false
+  opt :daemon, 'Run in the background as system daemon',
+      short: 'D', type: :boolean, default: false
+  opt :restart, 'Restart process when filesystem is updated',
+      short: 'r', type: :boolean, default: false
+  opt :list, 'Print name of files being watched'
+  opt :exec, 'Execute file as a script when file is updated',
+      short: 'e', type: :boolean, default: false
+  opt :include, 'Include files',
+      type: :string, default: File.join('**', '*')
+  opt :exclude, 'Exclude file(s) matching',
+      type: :string, default: nil
+  opt :interval, 'Interval to scan filesystem',
+      short: 'i', type: :float, default: 0.5
+  opt :spinner, 'Show an ascii spinner',
+      short: 's', type: :boolean, default: false
 end
 
-Trollop::die Trollop::educate if(ARGV.size == 0)
+Trollop.die Trollop.educate if ARGV.empty?
 
-files = []
-ARGV[0...-1].each do |a|
-  files << a
-end
+files = ARGV[0..-2]
 
-if(ARGV.length == 1)
-  files << ARGV[0]
-end
+files << ARGV.first if files.empty?
 
 def split_files_void_escaped_whitespace(files)
-  splitted_filenames = []
-  files.each do |name|
-    name = name.gsub(/\\\s/,'_ESCAPED_WHITESPACE_')
-    splitted_filenames << name.split(/\s/)
-  end
-  files = splitted_filenames.flatten.uniq
-  splitted_filenames = []
-  files.each do |name|
-    splitted_filenames << name.gsub('_ESCAPED_WHITESPACE_','\ ')
-  end
-  files = splitted_filenames
+  files
+    .map { |name| name.gsub(/\\\s/, '_ESCAPED_WHITESPACE_').split(/\s/) }
+    .flatten
+    .uniq
+    .map { |name| name.gsub('_ESCAPED_WHITESPACE_', '\ ') }
 end
 
 files = split_files_void_escaped_whitespace(files)
 child_pid = nil
 
 def restart(child_pid, env, cmd)
+  raise Errno::ESRCH unless child_pid
   Process.kill(9, child_pid)
   Process.wait(child_pid)
 rescue Errno::ESRCH
-  # already killed
+  nil # already killed
 ensure
-  return Process.spawn(env, cmd)
+  Process.spawn(env, cmd)
 end
 
-if(options[:exclude] != "")
-  options[:exclude] = split_files_void_escaped_whitespace(options[:exclude].split(" "))
+if options[:exclude].to_s != ''
+  options[:exclude] = split_files_void_escaped_whitespace(
+    options[:exclude].split(' ')
+  )
 end
 
 begin
-  fw = FileWatcher.new(files, options)
+  fw = Filewatcher.new(files, options)
 
-  if(options[:list])
+  if options[:list]
     puts 'Watching:'
     fw.last_found_filenames.each do |filename|
       puts " #{filename}"
@@ -91,77 +78,27 @@ begin
 
   Process.daemon(true, true) if options[:daemon]
 
-  fw.watch(options[:interval]) do |filename, event|
-    cmd = nil
-    if(options[:exec] and File.exist?(filename))
-      extension = filename[/(\.[^\.]*)$/,0]
-      runners = {
-        ".py" => "python",
-        ".js" => "node",
-        ".rb" => "ruby",
-        ".pl" => "perl",
-        ".awk" => "awk",
-        ".php" => "php",
-        ".phtml" => "php",
-        ".php4" => "php",
-        ".php3" => "php",
-        ".php5" => "php",
-        ".phps" => "php"
-      }
-      runner = runners[extension]
-      if(runner)
-        cmd = "env #{runner.to_s} #{filename}"
+  fw.watch do |filename, event|
+    cmd =
+      if options[:exec] && File.exist?(filename)
+        Filewatcher::Runner.new(filename).command
+      elsif ARGV.length > 1
+        ARGV[-1]
       end
-    elsif(ARGV.length > 1)
-      cmd = ARGV[-1]
-    end
 
-    if(cmd)
-      path = Pathname.new(filename)
-      env = {
-        'FILENAME' => filename,
-        'BASENAME' => path.basename.to_s,
-        'FILEDIR' => File.join(Pathname.new('.').realpath.to_s, path.parent.to_s), # Deprecated
-        'FSEVENT' => event.to_s, # Deprecated,
-        'EVENT' => event.to_s,
-        'DIRNAME' => File.join(Pathname.new('.').realpath.to_s, path.parent.to_s),
-        'ABSOLUTE_FILENAME' => File.join(Pathname.new('.').realpath.to_s, path.to_s),
-        'RELATIVE_FILENAME' => File.join(Pathname.new('.').to_s, path.to_s)
-      }
-
-      if(event != :delete)
-        ENV['FILEPATH'] = path.realpath.to_s
-      end
-
-      if(options[:restart])
-        if child_pid.nil?
-          child_pid = Process.spawn(env, cmd)
-        else
-          child_pid = restart(child_pid, env, cmd)
-        end
-      else
-        begin
-          pid = Process.spawn(env, cmd)
-          Process.wait()
-        rescue SystemExit, Interrupt
-          exit(0)
-        end
-      end
+    next puts "file #{event}: #{filename}" unless cmd
 
+    env = Filewatcher::Env.new(filename, event).to_h
+    if options[:restart]
+      child_pid = restart(child_pid, env, cmd)
     else
-      case(event)
-      when :changed
-        print "file updated"
-      when :delete
-        print "file deleted"
-      when :new
-        print "new file"
-      else
-        print event.to_s
+      begin
+        Process.spawn(env, cmd)
+        Process.wait
+      rescue SystemExit, Interrupt
+        exit(0)
       end
-      puts ": " + filename
     end
-
   end
 rescue SystemExit, Interrupt
   fw.finalize

data/lib/filewatcher.rb

@@ -1,66 +1,40 @@
-# coding: utf-8
+# frozen_string_literal: true
+
+require_relative 'filewatcher/cycles'
+
 # Simple file watcher. Detect changes in files and directories.
 #
 # Issues: Currently doesn't monitor changes in directorynames
-class FileWatcher
+class Filewatcher
+  include Filewatcher::Cycles
 
-  attr_accessor :filenames
-
-  def self.VERSION
-    return '0.5.4'
-  end
+  attr_writer :interval
 
   def update_spinner(label)
-    return nil unless @show_spinner
-    @spinner ||= %w(\\ | / -)
+    return unless @show_spinner
+    @spinner ||= %w[\\ | / -]
     print "#{' ' * 30}\r#{label}  #{@spinner.rotate!.first}\r"
   end
 
-  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]
+    @immediate = options[:immediate]
     @show_spinner = options[:spinner]
-    @interval = options[:interval]
+    @interval = options.fetch(:interval, 0.5)
+    @every = options[:every]
   end
 
-  def watch(sleep=0.5, &on_update)
-    trap("SIGINT") {return }
-    @sleep = sleep
-    if(@interval and @interval > 0)
-      @sleep = @interval
-    end
-    @stored_update = on_update
+  def watch(&on_update)
+    trap('SIGINT') { return }
+    @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
+    yield('', '') if @immediate
+
+    main_cycle
+
     @end_snapshot = mtime_snapshot
     finalize(&on_update)
   end
@@ -68,18 +42,18 @@ class FileWatcher
   def pause
     @pausing = true
     update_spinner('Initiating pause')
-    Kernel.sleep @sleep # Ensure we wait long enough to enter pause loop
-                        # in #watch
+    # 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
+    @last_snapshot = mtime_snapshot # resume with fresh snapshot
     @pausing = false
     update_spinner('Resuming')
-    Kernel.sleep @sleep # Wait long enough to exit pause loop in #watch
+    sleep @interval # Wait long enough to exit pause loop in #watch
   end
 
   # Ends the watch, allowing any remaining changes to be finalized.
@@ -87,103 +61,76 @@ class FileWatcher
   def stop
     @keep_watching = false
     update_spinner('Stopping')
-    return nil
+    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)
+    on_update = @on_update unless block_given?
+    while filesystem_updated?(@end_snapshot || mtime_snapshot)
       update_spinner('Finalizing')
-      on_update.call(@updated_file, @event)
+      trigger_changes(on_update)
     end
-    @end_snapshot =nil
-    return nil
+    @end_snapshot = nil
+  end
+
+  def last_found_filenames
+    last_snapshot.keys
+  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)
-
-    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
-    end
+    filenames = expand_directories(@unexpanded_filenames)
 
-    @filenames.each do |filename|
-      mtime = File.exist?(filename) ? File.stat(filename).mtime : Time.new(0)
+    # 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
-    return snapshot
+    snapshot
   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
+  def filesystem_updated?(snapshot = mtime_snapshot)
+    @changes = {}
 
-    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
+    # 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
-    return false
-  end
-
-  def last_found_filenames
-    @last_snapshot.keys
-  end
 
-  def expand_directories(patterns)
-    if(!patterns.kind_of?Array)
-      patterns = [patterns]
+    (last_snapshot.keys - snapshot.keys).each do |file|
+      @changes[file] = :deleted
     end
-    patterns.map { |it| Dir[fulldepth(expand_path(it))] }.flatten.uniq
-  end
-
-  private
 
-  def fulldepth(pattern)
-    if File.directory? pattern
-      "#{pattern}/**/*"
-    else
-      pattern
-    end
+    @last_snapshot = snapshot
+    @changes.any?
   end
 
-  def expand_path(pattern)
-    if pattern.start_with?('~')
-      File.expand_path(pattern)
-    else
-      pattern
+  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
-
 end
+
+# Require at end of file to not overwrite `Filewatcher` class
+require_relative 'filewatcher/version'