filewatcher 0.5.4 → 1.0.0

data/lib/filewatcher/cycles.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Filewatcher
+  # Module for all cycles in `Filewatcher#watch`
+  module Cycles
+    private
+
+    def main_cycle
+      while @keep_watching
+        @end_snapshot = mtime_snapshot if @pausing
+
+        pausing_cycle
+
+        watching_cycle
+
+        # test and clear @changes to prevent yielding the last
+        # changes twice if @keep_watching has just been set to false
+        trigger_changes
+      end
+    end
+
+    def pausing_cycle
+      while @keep_watching && @pausing
+        update_spinner('Pausing')
+        sleep @interval
+      end
+    end
+
+    def watching_cycle
+      while @keep_watching && !filesystem_updated? && !@pausing
+        update_spinner('Watching')
+        sleep @interval
+      end
+    end
+
+    def trigger_changes(on_update = @on_update)
+      thread = Thread.new do
+        changes = @every ? @changes : @changes.first(1)
+        changes.each do |filename, event|
+          on_update.call(filename, event)
+        end
+        @changes.clear
+      end
+      thread.join
+    end
+  end
+end

data/lib/filewatcher/env.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative '../filewatcher'
+
+class Filewatcher
+  # Class for building ENV variables for executable
+  class Env
+    def initialize(filename, event)
+      @filename = filename
+      @event = event
+      @path = Pathname.new(@filename)
+      @realpath = @path.realpath
+      @current_dir = Pathname.new(Dir.pwd)
+    end
+
+    def to_h
+      {
+        'FILEPATH' => (@realpath.to_s if @event != :deleted),
+        'FILENAME' => @filename,
+        'BASENAME' => @path.basename.to_s,
+        'EVENT' => @event.to_s,
+        'DIRNAME' => @path.parent.realpath.to_s,
+        'ABSOLUTE_FILENAME' => @realpath.to_s,
+        'RELATIVE_FILENAME' => @realpath.relative_path_from(@current_dir).to_s
+      }
+    end
+  end
+end

data/lib/filewatcher/runner.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Filewatcher
+  ## Get runner command by filename
+  class Runner
+    ## Define runners for `--exec` option
+    RUNNERS = {
+      python: %w[py],
+      node:   %w[js],
+      ruby:   %w[rb],
+      perl:   %w[pl],
+      awk:    %w[awk],
+      php:    %w[php phtml php4 php3 php5 phps]
+    }.freeze
+
+    def initialize(filename)
+      @filename = filename
+      @ext = File.extname(filename).delete('.')
+    end
+
+    def command
+      "env #{runner} #{@filename}" if runner
+    end
+
+    private
+
+    def runner
+      return @runner if defined?(@runner)
+      @runner, _exts = RUNNERS.find { |_cmd, exts| exts.include? @ext }
+      @runner
+    end
+  end
+end

data/lib/filewatcher/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../filewatcher'
+
+class Filewatcher
+  VERSION = '1.0.0'.freeze
+end

data/test/dumpers/env_dumper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative '../helper'
+
+dump_to_env_file(
+  %w[
+    FILENAME BASENAME EVENT DIRNAME ABSOLUTE_FILENAME
+    RELATIVE_FILENAME
+  ].map { |var| ENV[var] }.join(', ')
+)

data/test/dumpers/watched_dumper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative '../helper'
+
+dump_to_env_file 'watched'

data/test/filewatcher/test_env.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/filewatcher/env'
+
+describe Filewatcher::Env do
+  describe '#initialize' do
+    it 'should recieve filename and event' do
+      -> { Filewatcher::Env.new(__FILE__, :updated) }
+        .should.not.raise ArgumentError
+    end
+  end
+
+  describe '#to_h' do
+    before do
+      @init = proc do |file: __FILE__, event: :updated|
+        Filewatcher::Env.new(file, event).to_h
+      end
+      @env = @init.call
+    end
+
+    it 'should return Hash' do
+      @env.should.be.kind_of Hash
+    end
+
+    it 'should return Hash with FILEPATH key for created event' do
+      @init.call(event: :created)['FILEPATH']
+        .should.equal File.join(Dir.pwd, __FILE__)
+    end
+
+    it 'should return Hash with FILEPATH key for updated event' do
+      @init.call(event: :updated)['FILEPATH']
+        .should.equal File.join(Dir.pwd, __FILE__)
+    end
+
+    it 'should return Hash without FILEPATH key for deleted event' do
+      @init.call(event: :deleted)['FILEPATH']
+        .should.equal nil
+    end
+
+    it 'should return Hash with FILENAME key' do
+      @init.call(file: __FILE__)['FILENAME']
+        .should.equal __FILE__
+    end
+
+    it 'should return Hash with BASENAME key' do
+      @init.call(file: __FILE__)['BASENAME']
+        .should.equal File.basename(__FILE__)
+    end
+
+    it 'should return Hash with EVENT key' do
+      @init.call(event: :updated)['EVENT']
+        .should.equal 'updated'
+    end
+
+    it 'should return Hash with DIRNAME key' do
+      @init.call(file: __FILE__)['DIRNAME']
+        .should.equal File.dirname(File.join(Dir.pwd, __FILE__))
+    end
+
+    it 'should return Hash with ABSOLUTE_FILENAME key' do
+      @init.call(file: __FILE__)['ABSOLUTE_FILENAME']
+        .should.equal File.join(Dir.pwd, __FILE__)
+    end
+
+    it 'should return Hash with RELATIVE_FILENAME key' do
+      @init.call(file: __FILE__)['RELATIVE_FILENAME']
+        .should.equal __FILE__
+    end
+  end
+end

data/test/filewatcher/test_runner.rb

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

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

@@ -0,0 +1,134 @@
+# 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,181 +1,305 @@
-require 'rubygems'
-require 'bacon'
+# frozen_string_literal: true
+
 require 'fileutils'
-require File.expand_path("../lib/filewatcher.rb",File.dirname(__FILE__))
+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 FileWatcher do
+  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')
+        )
+      )
 
-  fixtures =
-    %w(test/fixtures/file4.rb
-       test/fixtures/subdir/file6.rb
-       test/fixtures/subdir/file5.rb
-       test/fixtures/file2.txt
-       test/fixtures/file1.txt
-       test/fixtures/file3.rb)
+      wr.run
 
-  explicit_relative_fixtures =  fixtures.map { |it| "./#{it}" }
+      wr.processed.should.be.empty
+    end
 
-  subfolder = 'test/fixtures/new_sub_folder'
+    it 'should handle absolute paths with globs' do
+      wr = WatchRun.new(
+        filewatcher: Filewatcher.new(
+          File.expand_path('test/tmp/**/*')
+        )
+      )
 
-  after do
-    FileUtils.rm_rf subfolder
-  end
+      wr.run
 
-  def includes_all(elements)
-    lambda { |it| elements.all? { |element| it.include? element }}
-  end
+      wr.processed.should.equal(
+        [[wr.filename, :updated]]
+      )
+    end
 
-  it "should exclude selected file patterns" do
-    filewatcher = FileWatcher.new(File.expand_path('test/fixtures/**/*'), :exclude => [File.expand_path("test/fixtures/**/*.txt")])
-    filtered_fixtures =
-      %w(test/fixtures/file4.rb
-         test/fixtures/subdir/file6.rb
-         test/fixtures/subdir/file5.rb
-         test/fixtures/file3.rb)
-    filewatcher.filenames.should.satisfy &includes_all(filtered_fixtures.map { |it| File.expand_path(it) })
-  end
-  
-  it "should handle absolute paths with globs" do
-    filewatcher = FileWatcher.new(File.expand_path('test/fixtures/**/*'))
+    it 'should handle globs' do
+      wr = WatchRun.new(
+        filewatcher: Filewatcher.new('test/tmp/**/*')
+      )
 
-    filewatcher.filenames.should.satisfy &includes_all(fixtures.map { |it| File.expand_path(it) })
-  end
-  
-  it "should handle globs" do
-    filewatcher = FileWatcher.new('test/fixtures/**/*')
+      wr.run
 
-    filewatcher.filenames.should.satisfy &includes_all(fixtures)
-  end
+      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/**/*')
+      )
 
-  it "should handle explicit relative paths with globs" do
-    filewatcher = FileWatcher.new('./test/fixtures/**/*')
+      wr.run
 
-    filewatcher.filenames.should.satisfy &includes_all(explicit_relative_fixtures)
-  end
+      wr.processed.should.equal(
+        [[wr.filename, :updated]]
+      )
+    end
 
-  it "should handle explicit relative paths" do
-    filewatcher = FileWatcher.new('./test/fixtures')
+    it 'should handle explicit relative paths' do
+      wr = WatchRun.new(
+        filewatcher: Filewatcher.new('./test/tmp')
+      )
 
-    filewatcher.filenames.should.satisfy &includes_all(explicit_relative_fixtures)
-  end
+      wr.run
+
+      wr.processed.should.equal(
+        [[wr.filename, :updated]]
+      )
+    end
 
-  it "should handle tilde expansion" do
-    filename = File.expand_path('~/file_watcher_1.txt')
-    open(filename, 'w') { |f| f.puts 'content1' }
+    it 'should handle tilde expansion' do
+      filename = File.expand_path('~/file_watcher_1.txt')
 
-    filewatcher = FileWatcher.new('~/file_watcher_1.txt')
+      wr = WatchRun.new(
+        filename: filename,
+        filewatcher: Filewatcher.new('~/file_watcher_1.txt')
+      )
 
-    begin
-      filewatcher.filenames.should == [filename]
-    ensure
-      FileUtils.rm(filename)
+      wr.run
+
+      wr.processed.should.equal(
+        [[filename, :updated]]
+      )
     end
-  end
 
-  it "should detect file deletions" do
-    filename = "test/fixtures/file1.txt"
-    open(filename,"w") { |f| f.puts "content1" }
-    filewatcher = FileWatcher.new(["test/fixtures"])
-    filewatcher.filesystem_updated?.should.be.false
-    FileUtils.rm(filename)
-    filewatcher.filesystem_updated?.should.be.true
-  end
+    it 'should immediately run with corresponding option' do
+      wr = WatchRun.new(
+        filewatcher: Filewatcher.new('**/*', immediate: true)
+      )
 
-  it "should detect file additions" do
-    filename = "test/fixtures/file1.txt"
-    FileUtils.rm(filename) if File.exists?(filename)
-    filewatcher = FileWatcher.new(["test/fixtures"])
-    filewatcher.filesystem_updated?.should.be.false
-    open(filename,"w") { |f| f.puts "content1" }
-    filewatcher.filesystem_updated?.should.be.true
-  end
+      wr.start
+      wr.stop
 
-  it "should detect file updates" do
-    filename = "test/fixtures/file1.txt"
-    open(filename,"w") { |f| f.puts "content1" }
-    filewatcher = FileWatcher.new(["test/fixtures"])
-    filewatcher.filesystem_updated?.should.be.false
-    sleep 1
-    open(filename,"w") { |f| f.puts "content2" }
-    filewatcher.filesystem_updated?.should.be.true
-  end
+      wr.processed.should.equal [['', '']]
+      wr.watched.should.be > 0
+    end
 
-  it "should detect new files in subfolders" do
-    FileUtils::mkdir_p subfolder
+    it 'should not be executed without immediate option and changes' do
+      wr = WatchRun.new(
+        filewatcher: Filewatcher.new('**/*', immediate: false)
+      )
 
-    filewatcher = FileWatcher.new(["./test/fixtures"])
-    filewatcher.filesystem_updated?.should.be.false
+      wr.start
+      wr.stop
 
-    open(subfolder + "/file.txt","w") { |f| f.puts "xyz" }
-    filewatcher.filesystem_updated?.should.be.true
+      wr.processed.should.be.empty
+      wr.watched.should.equal 0
+    end
   end
 
-  it "should detect new subfolders" do
-    filewatcher = FileWatcher.new(["test/fixtures"])
-    filewatcher.filesystem_updated?.should.be.false
+  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
 
-    FileUtils::mkdir_p subfolder
-    filewatcher.filesystem_updated?.should.be.true
+    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
 
-  it "should be stoppable" do
-    filewatcher = FileWatcher.new(["test/fixtures"])
-    thread = Thread.new(filewatcher){filewatcher.watch(0.1)}
-    sleep 0.2  # thread needs a chance to start
-    filewatcher.stop
-    thread.join.should.equal thread # Proves thread successfully joined
+  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
 
-  it "should be pauseable/resumable" do
-    filewatcher = FileWatcher.new(["test/fixtures"])
-    filewatcher.filesystem_updated?.should.be.false
-    processed = []
-    thread = Thread.new(filewatcher,processed) do
-      filewatcher.watch(0.1){|f,e| processed << f }
-    end
-    sleep 0.2  # thread needs a chance to start
-    filewatcher.pause
-    (1..4).each do |n|
-      open("test/fixtures/file#{n}.txt","w") { |f| f.puts "content#{n}" }
-    end
-    sleep 0.2 # Give filewatcher time to respond
-    processed.should.equal []  #update block should not have been called
-    filewatcher.resume
-    sleep 0.2 # Give filewatcher time to respond
-    processed.should.equal []  #update block still should not have been called
-    added_files = []
-    (5..7).each do |n|
-      added_files << "test/fixtures/file#{n}.txt"
-      open(added_files.last,"w") { |f| f.puts "content#{n}" }
-    end
-    sleep 0.2 # Give filewatcher time to respond
-    filewatcher.stop
-    processed.should.satisfy &includes_all(added_files)
+  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
 
-  it "should process all remaining changes at finalize" do
-    filewatcher = FileWatcher.new(["test/fixtures"])
-    filewatcher.filesystem_updated?.should.be.false
-    processed = []
-    thread = Thread.new(filewatcher,processed) do
-      filewatcher.watch(0.1){|f,e| processed << f }
-    end
-    sleep 0.2  # thread needs a chance to start
-    filewatcher.stop
-    thread.join
-    added_files = []
-    (1..4).each do |n|
-      added_files << "test/fixtures/file#{n}.txt"
-      open(added_files.last,"w") { |f| f.puts "content#{n}" }
-    end
-    filewatcher.finalize
-    puts "What is wrong with finalize:"
-    puts "Expect: #{added_files.inspect}"
-    puts "Actual: #{processed.inspect}"
-    # processed.should.satisfy &includes_all(added_files)
+  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