filewatcher 1.1.0 → 2.0.0.beta4

data/lib/filewatcher/version.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../filewatcher'
-
 class Filewatcher
-  VERSION = '1.1.0'.freeze
+  VERSION = '2.0.0.beta4'
 end

data/spec/filewatcher/snapshot_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/filewatcher/snapshot'
+
+describe Filewatcher::Snapshot do
+  let(:tmp_dir) { Filewatcher::SpecHelper::WatchRun::TMP_DIR }
+
+  let(:tmp_files) do
+    (1..4).map do |n|
+      File.join(tmp_dir, "file#{n}.txt")
+    end
+  end
+
+  def initialize_snapshot
+    described_class.new Dir[
+      File.join(tmp_dir, '**', '*')
+    ]
+  end
+
+  before do
+    FileUtils.mkdir_p tmp_dir
+
+    tmp_files.each_with_index do |tmp_file, n|
+      File.write tmp_file, "content#{n}"
+    end
+  end
+
+  after do
+    FileUtils.rm_r tmp_dir
+  end
+
+  describe '#initialize' do
+    subject(:snapshot) { initialize_snapshot }
+
+    it do
+      snapshot.each do |filename, snapshot_file|
+        expect(snapshot_file.mtime).to eq File.mtime(filename)
+      end
+    end
+  end
+
+  describe '#-' do
+    subject(:difference) { second_snapshot - first_snapshot }
+
+    let(:first_snapshot) { initialize_snapshot }
+    let(:second_snapshot) { initialize_snapshot }
+    let(:new_file) { File.join(tmp_dir, 'file5.txt') }
+
+    before do
+      first_snapshot
+
+      ## 1 second or more: https://github.com/oracle/truffleruby/issues/2337
+      sleep 1
+
+      File.write tmp_files[1], 'new content'
+      File.delete tmp_files[2]
+      File.write(new_file, 'new file')
+    end
+
+    it do
+      expect(difference).to eq(
+        tmp_files[1] => :updated,
+        tmp_files[2] => :deleted,
+        new_file => :created
+      )
+    end
+  end
+end

data/spec/filewatcher/version_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/filewatcher/version'
+
+describe 'Filewatcher::VERSION' do
+  subject { Object.const_get(self.class.description) }
+
+  it { is_expected.to match(/^\d+\.\d+\.\d+(\.\w+(\.\d+)?)?$/) }
+end

data/spec/filewatcher_spec.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../lib/filewatcher'
+
+describe Filewatcher do
+  subject(:processed) { watch_run.processed }
+
+  before do
+    FileUtils.mkdir_p tmp_dir
+  end
+
+  after do
+    logger.debug "FileUtils.rm_r #{tmp_dir}"
+    FileUtils.rm_r tmp_dir
+
+    Filewatcher::SpecHelper.wait seconds: 5, interval: 0.2 do
+      !File.exist?(tmp_dir)
+    end
+  end
+
+  def initialize_filewatcher(path, options = {})
+    described_class.new(path, options.merge(logger: logger))
+  end
+
+  let(:tmp_dir) { Filewatcher::SpecHelper::WatchRun::TMP_DIR }
+  let(:logger) { Filewatcher::SpecHelper.logger }
+
+  let(:filename) { 'tmp_file.txt' }
+  let(:action) { :update }
+  let(:directory) { false }
+  ## TODO: Check its needless
+  let(:every) { false }
+  let(:immediate) { false }
+  let(:interval) { 0.2 }
+  let(:filewatcher) do
+    initialize_filewatcher(
+      File.join(tmp_dir, '**', '*'), interval: interval, every: every, immediate: immediate
+    )
+  end
+
+  let(:watch_run) do
+    Filewatcher::SpecHelper::RubyWatchRun.new(
+      filename: filename, filewatcher: filewatcher, action: action,
+      directory: directory
+    )
+  end
+
+  let(:processed_files) { watch_run.processed.flat_map(&:keys) }
+
+  describe '.print_version' do
+    subject(:method_call) { described_class.print_version }
+
+    let(:ruby_version_regexp) { '(j|truffle)?ruby \d+\.\d+\.\d+.*' }
+    let(:filewatcher_version_regexp) { "Filewatcher #{Filewatcher::VERSION}" }
+
+    it do
+      expect { method_call }.to output(
+        /^#{ruby_version_regexp}\n#{filewatcher_version_regexp}$/
+      ).to_stdout_from_any_process
+    end
+  end
+
+  describe '#initialize' do
+    describe 'regular run' do
+      before { watch_run.run }
+
+      context 'with excluding selected file patterns' do
+        let(:filewatcher) do
+          initialize_filewatcher(
+            File.expand_path('spec/tmp/**/*'),
+            exclude: File.expand_path('spec/tmp/**/*.txt')
+          )
+        end
+
+        it { is_expected.to be_empty }
+      end
+
+      context 'with absolute paths including globs' do
+        let(:filewatcher) do
+          initialize_filewatcher(
+            File.expand_path('spec/tmp/**/*')
+          )
+        end
+
+        it { is_expected.to eq [{ watch_run.filename => :updated }] }
+      end
+
+      context 'with globs' do
+        let(:filewatcher) { initialize_filewatcher('spec/tmp/**/*') }
+
+        it { is_expected.to eq [{ watch_run.filename => :updated }] }
+      end
+
+      context 'with explicit relative paths with globs' do
+        let(:filewatcher) { initialize_filewatcher('./spec/tmp/**/*') }
+
+        it { is_expected.to eq [{ watch_run.filename => :updated }] }
+      end
+
+      context 'with explicit relative paths' do
+        let(:filewatcher) { initialize_filewatcher('./spec/tmp') }
+
+        it { is_expected.to eq [{ watch_run.filename => :updated }] }
+      end
+
+      context 'with tilde expansion' do
+        let(:filename) { File.expand_path('~/file_watcher_1.txt') }
+
+        let(:filewatcher) { initialize_filewatcher('~/file_watcher_1.txt') }
+
+        it { is_expected.to eq [{ filename => :updated }] }
+      end
+    end
+
+    describe '`:immediate` option' do
+      before do
+        watch_run.start
+        watch_run.stop
+      end
+
+      context 'when is `true`' do
+        let(:immediate) { true }
+
+        it { is_expected.to eq [{ '' => '' }] }
+
+        describe 'when watched' do
+          subject { watch_run.watched }
+
+          it { is_expected.to be > 0 }
+        end
+      end
+
+      context 'when is `false`' do
+        let(:immediate) { false }
+
+        it { is_expected.to be_empty }
+
+        describe 'when watched' do
+          subject { watch_run.watched }
+
+          it { is_expected.to eq 0 }
+        end
+      end
+    end
+  end
+
+  describe '#watch' do
+    before do
+      FileUtils.mkdir_p subdirectory if defined? subdirectory
+
+      watch_run.run
+    end
+
+    describe 'detecting file deletions' do
+      let(:action) { :delete }
+
+      it { is_expected.to eq [{ watch_run.filename => :deleted }] }
+    end
+
+    context 'when there are file additions' do
+      let(:action) { :create }
+
+      it { is_expected.to eq [{ watch_run.filename => :created }] }
+    end
+
+    context 'when there are file updates' do
+      let(:action) { :update }
+
+      it { is_expected.to eq [{ watch_run.filename => :updated }] }
+    end
+
+    context 'when there are new files in subdirectories' do
+      let(:subdirectory) { File.expand_path('spec/tmp/new_sub_directory') }
+
+      let(:filename) { File.join(subdirectory, 'file.txt') }
+      let(:action) { :create }
+      let(:every) { true }
+      ## https://github.com/filewatcher/filewatcher/pull/115#issuecomment-674581595
+      let(:interval) { 0.4 }
+
+      it do
+        expect(processed).to eq [
+          { subdirectory => :updated, watch_run.filename => :created }
+        ]
+      end
+    end
+
+    context 'when there are new subdirectories' do
+      let(:filename) { 'new_sub_directory' }
+      let(:directory) { true }
+      let(:action) { :create }
+
+      it { is_expected.to eq [{ watch_run.filename => :created }] }
+    end
+  end
+
+  describe '#stop' do
+    subject { watch_run.thread.join }
+
+    before do
+      watch_run.start
+      watch_run.filewatcher.stop
+    end
+
+    it { is_expected.to eq watch_run.thread }
+  end
+
+  def write_tmp_files(range)
+    logger.debug "#{__method__} #{range}"
+
+    directory = 'spec/tmp'
+    FileUtils.mkdir_p directory
+
+    range.to_a.map do |n|
+      File.write(file = "#{directory}/file#{n}.txt", "content#{n}")
+
+      Filewatcher::SpecHelper.wait seconds: 1
+
+      file
+    end
+  end
+
+  shared_context 'when paused' do
+    let(:action) { :create }
+    let(:every) { true }
+
+    before do
+      watch_run.start
+
+      logger.debug 'filewatcher.pause'
+      watch_run.filewatcher.pause
+
+      Filewatcher::SpecHelper.wait seconds: 1
+
+      write_tmp_files 1..4
+    end
+  end
+
+  describe '#pause' do
+    include_context 'when paused'
+
+    # update block should not have been called
+    it { is_expected.to be_empty }
+  end
+
+  describe '#resume' do
+    include_context 'when paused'
+
+    before do
+      logger.debug 'filewatcher.resume'
+      watch_run.filewatcher.resume
+    end
+
+    after do
+      watch_run.stop
+    end
+
+    describe 'changes while paused' do
+      # update block still should not have been called
+      it { is_expected.to be_empty }
+    end
+
+    describe 'changes after resumed' do
+      subject { processed_files }
+
+      let(:added_files) { write_tmp_files 5..7 }
+
+      before do
+        added_files
+
+        watch_run.wait
+
+        watch_run.filewatcher.stop
+        watch_run.stop
+      end
+
+      it { is_expected.to include_all_files added_files }
+    end
+  end
+
+  describe '#finalize' do
+    subject { processed_files }
+
+    let(:action) { :create }
+    let(:every) { true }
+
+    let(:added_files) { write_tmp_files 1..4 }
+
+    before do
+      watch_run.start
+      watch_run.filewatcher.stop
+      watch_run.thread.join
+
+      added_files
+
+      watch_run.filewatcher.finalize
+    end
+
+    it { is_expected.to include_all_files added_files }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
+if ENV['CODECOV_TOKEN']
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+require_relative '../lib/filewatcher/spec_helper'
+
+require_relative 'spec_helper/ruby_watch_run'
+
+## For case when required from dumpers
+if Object.const_defined?(:RSpec)
+  RSpec::Matchers.define :include_all_files do |expected|
+    match do |actual|
+      expected.all? { |file| actual.include? File.expand_path(file) }
+    end
+  end
+end

data/spec/spec_helper/ruby_watch_run.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class Filewatcher
+  module SpecHelper
+    class RubyWatchRun < WatchRun
+      attr_reader :filewatcher, :thread, :watched, :processed
+
+      def initialize(filewatcher:, **args)
+        super(**args)
+        @filewatcher = filewatcher
+
+        @mutex = Mutex.new
+      end
+
+      def start
+        super
+        @thread = thread_initialize
+        # thread needs a chance to start
+        wait seconds: 1
+        wait do
+          keep_watching = filewatcher.keep_watching
+          debug "keep_watching = #{keep_watching}"
+          keep_watching
+        end
+      end
+
+      def stop
+        thread.exit
+
+        wait do
+          thread.stop?
+        end
+
+        super
+      end
+
+      def wait(seconds: 1)
+        super seconds: seconds, interval: filewatcher.interval
+      end
+
+      private
+
+      def make_changes
+        super
+
+        # Some OS, file systems and Ruby interpretators
+        # doesn't catch milliseconds of `File.mtime`
+        wait do
+          @mutex.synchronize do
+            debug "processed = #{processed}"
+            debug "processed.any? = #{processed.any?}"
+            processed.any?
+          end
+        end
+      end
+
+      def thread_initialize
+        @watched ||= 0
+        @processed = []
+        Thread.new { setup_filewatcher }
+      end
+
+      def setup_filewatcher
+        debug 'setup_filewatcher'
+        debug filewatcher.inspect
+        filewatcher.watch do |changes|
+          debug filewatcher.inspect
+          @mutex.synchronize do
+            debug "watch callback: changes = #{changes.inspect}"
+            increment_watched
+            @processed.push(changes)
+            # debug 'pushed to processed'
+          end
+        end
+      end
+
+      def increment_watched
+        @watched += 1
+      end
+    end
+  end
+end