filewatcher 1.0.0 → 2.0.0.beta2

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,134 +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, :filewatcher, :thread, :watched, :processed
-
-  def initialize(
-    filename: 'tmp_file.txt',
-    directory: false,
-    every: false,
-    filewatcher: Filewatcher.new(
-      File.join(TMP_DIR, '**', '*'), interval: 0.1, every: every
-    ),
-    action: :update
-  )
-    @filename =
-      filename.start_with?('/', '~') ? filename : File.join(TMP_DIR, filename)
-    @directory = directory
-    @filewatcher = filewatcher
-    @action = action
-  end
-
-  def start
-    File.write(@filename, 'content1') unless @action == :create
-
-    @thread = thread_initialize
-    sleep 3 # thread needs a chance to start
-  end
-
-  def run
-    start
-
-    make_changes
-    # Some OS, filesystems and Ruby interpretators
-    # doesn't catch milliseconds of `File.mtime`
-    sleep 3
-
-    stop
-  end
-
-  def stop
-    FileUtils.rm_r(@filename) if File.exist?(@filename)
-    @thread.exit
-    sleep 3
-  end
-
-  private
-
-  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 make_changes
-    return FileUtils.remove(@filename) if @action == :delete
-    return FileUtils.mkdir_p(@filename) if @directory
-    File.write(@filename, 'content2')
-  end
-end
-
-class ShellWatchRun
-  EXECUTABLE = "#{'ruby ' if Gem.win_platform?}" \
-    "#{File.realpath File.join(__dir__, '..', 'bin', 'filewatcher')}".freeze
-
-  attr_reader :output
-
-  def initialize(
-    options: '',
-    dumper: :watched,
-    output: File.join(WatchRun::TMP_DIR, 'env')
-  )
-    @options = options
-    @dumper = dumper
-    @output = output
-  end
-
-  def start
-    @pid = spawn(
-      "#{EXECUTABLE} #{@options} \"#{WatchRun::TMP_DIR}/foo*\"" \
-        " \"ruby #{File.join(__dir__, 'dumpers', "#{@dumper}_dumper.rb")}\""
-    )
-    Process.detach(@pid)
-    sleep 12
-  end
-
-  def run
-    start
-
-    make_changes
-
-    stop
-  end
-
-  def stop
-    Process.kill('KILL', @pid)
-    sleep 6
-  end
-
-  private
-
-  def make_changes
-    FileUtils.touch "#{WatchRun::TMP_DIR}/foo.txt"
-    sleep 12
-  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(WatchRun::TMP_DIR, 'env'), content
-end

data/test/test_filewatcher.rb

@@ -1,305 +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
-  end
-
-  describe '#initialize' do
-    it 'should exclude selected file patterns' do
-      wr = WatchRun.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 = WatchRun.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 = WatchRun.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 = WatchRun.new(
-        filewatcher: Filewatcher.new('./test/tmp/**/*')
-      )
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :updated]]
-      )
-    end
-
-    it 'should handle explicit relative paths' do
-      wr = WatchRun.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 = WatchRun.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 = WatchRun.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 = WatchRun.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 = WatchRun.new(action: :delete)
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :deleted]]
-      )
-    end
-
-    it 'should detect file additions' do
-      wr = WatchRun.new(action: :create)
-
-      wr.run
-
-      wr.processed.should.equal(
-        [[wr.filename, :created]]
-      )
-    end
-
-    it 'should detect file updates' do
-      wr = WatchRun.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 = WatchRun.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 = WatchRun.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 = WatchRun.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 = WatchRun.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 = WatchRun.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 = WatchRun::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' do
-      swr = ShellWatchRun.new(
-        dumper: :env
-      )
-
-      swr.run
-
-      File.read(swr.output)
-        .should.equal(
-          %W[
-            #{tmp_dir}/foo.txt
-            foo.txt
-            created
-            #{tmp_dir}
-            #{tmp_dir}/foo.txt
-            test/tmp/foo.txt
-          ].join(', ')
-        )
-    end
-
-    it 'should be executed immediately with corresponding option' do
-      swr = ShellWatchRun.new(
-        options: '--immediate',
-        dumper: :watched
-      )
-
-      swr.start
-      swr.stop
-
-      File.exist?(swr.output).should.be.true
-      File.read(swr.output).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?(swr.output).should.be.false
-    end
-  end
-end