filewatcher 0.5.4 → 2.0.0.beta1

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_given?
+        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,74 @@
+# frozen_string_literal: true
+
+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

data/lib/filewatcher/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Filewatcher
+  VERSION = '2.0.0.beta1'
+end

data/spec/filewatcher/snapshot_spec.rb

@@ -0,0 +1,67 @@
+# 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
+
+      sleep 0.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,11 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/filewatcher/version'
+
+describe 'Filewatcher::VERSION' do
+  subject { Object.const_get(self.class.description) }
+
+  it { is_expected.to be_kind_of String }
+
+  it { is_expected.not_to be_empty }
+end

data/spec/filewatcher_spec.rb

@@ -0,0 +1,289 @@
+# 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 '#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