filewatcher 1.0.1 → 2.0.0.beta3

data/test/filewatcher/test_runner.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/filewatcher/runner'
-
-describe Filewatcher::Runner do
-  before do
-    @init = proc do |filename|
-      Filewatcher::Runner.new(filename)
-    end
-  end
-
-  describe '#initialize' do
-    it 'should recieve filename' do
-      -> { @init.call('file.txt') }
-        .should.not.raise ArgumentError
-    end
-  end
-
-  describe '#command' do
-    it 'should return correct command for file with .py extension' do
-      @init.call('file.py').command
-        .should.equal 'env python file.py'
-    end
-
-    it 'should return correct command for file with .js extension' do
-      @init.call('file.js').command
-        .should.equal 'env node file.js'
-    end
-
-    it 'should return correct command for file with .rb extension' do
-      @init.call('file.rb').command
-        .should.equal 'env ruby file.rb'
-    end
-
-    it 'should return correct command for file with .pl extension' do
-      @init.call('file.pl').command
-        .should.equal 'env perl file.pl'
-    end
-
-    it 'should return correct command for file with .awk extension' do
-      @init.call('file.awk').command
-        .should.equal 'env awk file.awk'
-    end
-
-    it 'should return correct command for file with .php extension' do
-      @init.call('file.php').command
-        .should.equal 'env php file.php'
-    end
-
-    it 'should return correct command for file with .phtml extension' do
-      @init.call('file.phtml').command
-        .should.equal 'env php file.phtml'
-    end
-
-    it 'should return correct command for file with .php4 extension' do
-      @init.call('file.php4').command
-        .should.equal 'env php file.php4'
-    end
-
-    it 'should return correct command for file with .php3 extension' do
-      @init.call('file.php3').command
-        .should.equal 'env php file.php3'
-    end
-
-    it 'should return correct command for file with .php5 extension' do
-      @init.call('file.php5').command
-        .should.equal 'env php file.php5'
-    end
-
-    it 'should return correct command for file with .phps extension' do
-      @init.call('file.phps').command
-        .should.equal 'env php file.phps'
-    end
-  end
-end

data/test/filewatcher/test_version.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/filewatcher/version'
-
-describe Filewatcher::VERSION do
-  it 'should exist as constant' do
-    Filewatcher.const_defined?(:VERSION).should.be.true
-  end
-
-  it 'should be an instance of String' do
-    Filewatcher::VERSION.class.should.equal String
-  end
-end

data/test/helper.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-require 'bacon'
-require 'bacon/custom_matchers_messages'
-
-begin
-  require 'pry-byebug'
-rescue LoadError
-  nil
-end
-
-class WatchRun
-  TMP_DIR = File.join(__dir__, 'tmp')
-
-  attr_reader :filename
-
-  def initialize(
-    filename: 'tmp_file.txt',
-    directory: false,
-    action: :update
-  )
-    @filename =
-      filename.start_with?('/', '~') ? filename : File.join(TMP_DIR, filename)
-    @directory = directory
-    @action = action
-  end
-
-  def start
-    File.write(@filename, 'content1') unless @action == :create
-  end
-
-  def run
-    start
-
-    make_changes
-
-    stop
-  end
-
-  def stop
-    FileUtils.rm_r(@filename) if File.exist?(@filename)
-  end
-
-  private
-
-  def make_changes
-    if @action == :delete
-      FileUtils.remove(@filename)
-    elsif @directory
-      FileUtils.mkdir_p(@filename)
-    else
-      File.write(@filename, 'content2')
-    end
-  end
-end
-
-class RubyWatchRun < WatchRun
-  attr_reader :filewatcher, :thread, :watched, :processed
-
-  def initialize(
-    every: false,
-    filewatcher: Filewatcher.new(
-      File.join(TMP_DIR, '**', '*'), interval: 0.1, every: every
-    ),
-    **args
-  )
-    super(**args)
-    @filewatcher = filewatcher
-  end
-
-  def start
-    super
-    @thread = thread_initialize
-    # thread needs a chance to start
-    wait 3 do
-      filewatcher.keep_watching
-    end
-  end
-
-  def stop
-    thread.exit
-
-    wait 3 do
-      thread.stop?
-    end
-
-    super
-  end
-
-  private
-
-  def make_changes
-    super
-
-    # Some OS, filesystems and Ruby interpretators
-    # doesn't catch milliseconds of `File.mtime`
-    wait 3 do
-      processed.any?
-    end
-  end
-
-  def thread_initialize
-    @watched ||= 0
-    Thread.new(
-      @filewatcher, @processed = []
-    ) do |filewatcher, processed|
-      filewatcher.watch do |filename, event|
-        increment_watched
-        processed.push([filename, event])
-      end
-    end
-  end
-
-  def increment_watched
-    @watched += 1
-  end
-
-  def wait(seconds)
-    max_count = seconds / filewatcher.interval
-    count = 0
-    while count < max_count && !yield
-      sleep filewatcher.interval
-      count += 1
-    end
-  end
-end
-
-class ShellWatchRun < WatchRun
-  EXECUTABLE = "#{'ruby ' if Gem.win_platform?}" \
-    "#{File.realpath File.join(__dir__, '..', 'bin', 'filewatcher')}".freeze
-
-  SLEEP_MULTIPLIER = RUBY_PLATFORM == 'java' ? 5 : 1
-
-  ENV_FILE = File.join(TMP_DIR, 'env')
-
-  def initialize(
-    options: {},
-    dumper: :watched,
-    **args
-  )
-    super(**args)
-    @options = options
-    @options[:interval] ||= 0.1
-    @options_string =
-      @options.map { |key, value| "--#{key}=#{value}" }.join(' ')
-    @dumper = dumper
-  end
-
-  def start
-    super
-
-    @pid = spawn(
-      "#{EXECUTABLE} #{@options_string} \"#{@filename}\"" \
-        " \"ruby #{File.join(__dir__, 'dumpers', "#{@dumper}_dumper.rb")}\"",
-      pgroup: true
-    )
-
-    Process.detach(@pid)
-
-    wait 12 do
-      pid_state == 'S' && (!@options[:immediate] || File.exist?(ENV_FILE))
-    end
-
-    # a little more time
-    sleep 1 * SLEEP_MULTIPLIER
-  end
-
-  def stop
-    ## Problems: https://github.com/thomasfl/filewatcher/pull/83
-    ## Solution: https://stackoverflow.com/a/45032252/2630849
-    Process.kill('TERM', -Process.getpgid(@pid))
-    Process.waitall
-
-    wait 12 do
-      pid_state.empty?
-    end
-
-    # a little more time
-    sleep 1 * SLEEP_MULTIPLIER
-
-    super
-  end
-
-  private
-
-  def make_changes
-    super
-
-    wait 12 do
-      File.exist?(ENV_FILE)
-    end
-  end
-
-  def pid_state
-    ## For macOS output:
-    ## https://travis-ci.org/thomasfl/filewatcher/jobs/304433538
-    `ps -ho state -p #{@pid}`.sub('STAT', '').strip
-  end
-
-  def wait(seconds)
-    max_count = seconds / @options[:interval]
-    count = 0
-    while count < max_count && !yield
-      sleep @options[:interval]
-      count += 1
-    end
-  end
-end
-
-custom_matcher :include_all_files do |obj, elements|
-  elements.all? { |element| obj.include? File.expand_path(element) }
-end
-
-def dump_to_env_file(content)
-  File.write File.join(ShellWatchRun::ENV_FILE), content
-end

data/test/test_filewatcher.rb

@@ -1,340 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require_relative '../lib/filewatcher'
-
-describe Filewatcher do
-  before do
-    FileUtils.mkdir_p WatchRun::TMP_DIR
-  end
-
-  after do
-    FileUtils.rm_r WatchRun::TMP_DIR
-
-    interval = 0.1
-    wait = 5
-    count = 0
-    while File.exist?(WatchRun::TMP_DIR) && count < (wait / interval)
-      sleep interval
-    end
-  end
-
-  describe '#initialize' do
-    it 'should exclude selected file patterns' do
-      wr = RubyWatchRun.new(
-        filewatcher: Filewatcher.new(
-          File.expand_path('test/tmp/**/*'),
-          exclude: File.expand_path('test/tmp/**/*.txt')
-        )
-      )
-
-      wr.run
-
-      wr.processed.should.be.empty
-    end
-
-    it 'should handle absolute paths with globs' do
-      wr = RubyWatchRun.new(
-        filewatcher: Filewatcher.new(
-          File.expand_path('test/tmp/**/*')
-        )
-      )
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :updated]]
-      )
-    end
-
-    it 'should handle globs' do
-      wr = RubyWatchRun.new(
-        filewatcher: Filewatcher.new('test/tmp/**/*')
-      )
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :updated]]
-      )
-    end
-
-    it 'should handle explicit relative paths with globs' do
-      wr = RubyWatchRun.new(
-        filewatcher: Filewatcher.new('./test/tmp/**/*')
-      )
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :updated]]
-      )
-    end
-
-    it 'should handle explicit relative paths' do
-      wr = RubyWatchRun.new(
-        filewatcher: Filewatcher.new('./test/tmp')
-      )
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :updated]]
-      )
-    end
-
-    it 'should handle tilde expansion' do
-      filename = File.expand_path('~/file_watcher_1.txt')
-
-      wr = RubyWatchRun.new(
-        filename: filename,
-        filewatcher: Filewatcher.new('~/file_watcher_1.txt')
-      )
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[filename, :updated]]
-      )
-    end
-
-    it 'should immediately run with corresponding option' do
-      wr = RubyWatchRun.new(
-        filewatcher: Filewatcher.new('**/*', immediate: true)
-      )
-
-      wr.start
-      wr.stop
-
-      wr.processed.should.equal [['', '']]
-      wr.watched.should.be > 0
-    end
-
-    it 'should not be executed without immediate option and changes' do
-      wr = RubyWatchRun.new(
-        filewatcher: Filewatcher.new('**/*', immediate: false)
-      )
-
-      wr.start
-      wr.stop
-
-      wr.processed.should.be.empty
-      wr.watched.should.equal 0
-    end
-  end
-
-  describe '#watch' do
-    it 'should detect file deletions' do
-      wr = RubyWatchRun.new(action: :delete)
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :deleted]]
-      )
-    end
-
-    it 'should detect file additions' do
-      wr = RubyWatchRun.new(action: :create)
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :created]]
-      )
-    end
-
-    it 'should detect file updates' do
-      wr = RubyWatchRun.new(action: :update)
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :updated]]
-      )
-    end
-
-    it 'should detect new files in subfolders' do
-      FileUtils.mkdir_p subfolder = File.expand_path('test/tmp/new_sub_folder')
-
-      wr = RubyWatchRun.new(
-        filename: File.join(subfolder, 'file.txt'),
-        action: :create,
-        every: true
-      )
-      wr.run
-      wr.processed.should.equal(
-        [
-          [subfolder, :updated],
-          [wr.filename, :created]
-        ]
-      )
-    end
-
-    it 'should detect new subfolders' do
-      subfolder = 'new_sub_folder'
-
-      wr = RubyWatchRun.new(
-        filename: subfolder,
-        directory: true,
-        action: :create
-      )
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :created]]
-      )
-    end
-  end
-
-  describe '#stop' do
-    it 'should work' do
-      wr = RubyWatchRun.new
-
-      wr.start
-
-      wr.filewatcher.stop
-
-      # Proves thread successfully joined
-      wr.thread.join.should.equal wr.thread
-    end
-  end
-
-  describe '#pause, #resume' do
-    it 'should work' do
-      wr = RubyWatchRun.new(action: :create, every: true)
-
-      wr.start
-
-      wr.filewatcher.pause
-
-      (1..4).each do |n|
-        File.write("test/tmp/file#{n}.txt", "content#{n}")
-      end
-      sleep 0.2 # Give filewatcher time to respond
-
-      # update block should not have been called
-      wr.processed.should.be.empty
-
-      wr.filewatcher.resume
-      sleep 0.2 # Give filewatcher time to respond
-
-      # update block still should not have been called
-      wr.processed.should.be.empty
-
-      added_files = (5..7).to_a.map do |n|
-        File.write(file = "test/tmp/file#{n}.txt", "content#{n}")
-        file
-      end
-      sleep 0.2 # Give filewatcher time to respond
-
-      wr.filewatcher.stop
-      wr.stop
-      wr.processed.map(&:first).should include_all_files(added_files)
-    end
-  end
-
-  describe '#finalize' do
-    it 'should process all remaining changes' do
-      wr = RubyWatchRun.new(action: :create, every: true)
-
-      wr.start
-
-      wr.filewatcher.stop
-      wr.thread.join
-
-      added_files = (1..4).to_a.map do |n|
-        File.write(file = "test/tmp/file#{n}.txt", "content#{n}")
-        file
-      end
-
-      wr.filewatcher.finalize
-
-      wr.processed.map(&:first).should include_all_files(added_files)
-    end
-  end
-
-  describe 'executable' do
-    tmp_dir = ShellWatchRun::TMP_DIR
-
-    it 'should run' do
-      null_output = Gem.win_platform? ? 'NUL' : '/dev/null'
-      system("#{ShellWatchRun::EXECUTABLE} > #{null_output}")
-        .should.be.true
-    end
-
-    it 'should set correct ENV variables for file creation' do
-      filename = 'foo.txt'
-
-      swr = ShellWatchRun.new(
-        filename: filename,
-        action: :create,
-        dumper: :env
-      )
-
-      swr.run
-
-      File.read(ShellWatchRun::ENV_FILE)
-        .should.equal(
-          %W[
-            #{tmp_dir}/#{filename}
-            #{filename}
-            created
-            #{tmp_dir}
-            #{tmp_dir}/#{filename}
-            test/tmp/#{filename}
-          ].join(', ')
-        )
-    end
-
-    it 'should set correct ENV variables for file deletion' do
-      filename = 'foo.txt'
-
-      swr = ShellWatchRun.new(
-        filename: filename,
-        action: :delete,
-        dumper: :env
-      )
-
-      swr.run
-
-      File.read(ShellWatchRun::ENV_FILE)
-        .should.equal(
-          %W[
-            #{tmp_dir}/#{filename}
-            #{filename}
-            deleted
-            #{tmp_dir}
-            #{tmp_dir}/#{filename}
-            test/tmp/#{filename}
-          ].join(', ')
-        )
-    end
-
-    it 'should be executed immediately with corresponding option' do
-      swr = ShellWatchRun.new(
-        options: { immediate: true },
-        dumper: :watched
-      )
-
-      swr.start
-      swr.stop
-
-      File.exist?(ShellWatchRun::ENV_FILE).should.be.true
-      File.read(ShellWatchRun::ENV_FILE).should.equal 'watched'
-    end
-
-    it 'should not be executed without immediate option and changes' do
-      swr = ShellWatchRun.new(
-        options: {},
-        dumper: :watched
-      )
-
-      swr.start
-      swr.stop
-
-      File.exist?(ShellWatchRun::ENV_FILE).should.be.false
-    end
-  end
-end