feather_watch 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c365a117cc400f3b83860aabf245dbdd24a87d0e
-  data.tar.gz: e37efc790a575ed9c9beb2f2699d6e4eff745fbd
+  metadata.gz: 30971c259a7028609aabaf9d2ef3a859fe14083c
+  data.tar.gz: dddb2c7ab3a28d0382a152ab857531757f2551a1
 SHA512:
-  metadata.gz: 54894b9dc54e207f0afc675e75ceddcfb036bfa502d55bbef66fdfcc25b647e5ab85e86807c9a6783d04f8aeaea2868cf61ee4994043ebcbef77372b767f144d
-  data.tar.gz: 5ccbdba157e5c9cab6cfd23e4033a837259975a81e1cefa0cf6e6900f1543e637f822f90db76cbe0bf8b15bb8b6309521350953484406650548bcec5b0484ef0
+  metadata.gz: 1dd10630dfbf7b1de3dec9592a4327ec5a097cbb93786256b5a44796427c67002aa7881a030296dbc4edafd09dc7bc32cbf02103b422425267ba105cc090173d
+  data.tar.gz: cec18243d9533413f85b28691b0f1745ba7fbf41fd09cca1ea1ac3e6956e9720481efa34c6083eb61de8c1340a47ec521bafad79f28c207ca488a1f30e608df5

data/README.md

@@ -3,7 +3,7 @@
 Light weight, cross platform, file system watcher. 
 
 
-### Should work windows, but not yet tested becase I do not have access to a windows machine now. If you do, I would love for you to run the specs and see if it works :)
+(!) Should work on windows, but I have not yet tested it because I do not have access to a windows machine right now. If you do, I would love for you to run the specs and see if it works :)
 
 [![Build Status](https://travis-ci.org/stephan-nordnes-eriksen/feather_watch.svg?branch=master)](https://travis-ci.org/stephan-nordnes-eriksen/feather_watch)
 
@@ -40,9 +40,9 @@ Or install it yourself as:
 
 
 # Important Notes!
-Events on OSx, also known as darwin, is currenty an approximation as the underlying libraries does not currently support actual events. Thus on OSx, you get `:removed` if the file recieved does not exist by checking File.file?(the_file). If it does exist you get `:modified`. So you will **not** get any `:added` events on OSx.
+Events on OSx, also known as darwin, is current an approximation as the underlying libraries does not currently support actual events. Thus on OSx, you get `:removed` if the file received does not exist by checking File.file?(the_file). If it does exist you get `:modified`. So you will **not** get any `:added` events on OSx.
 
-Feather Watch will recieve very many file events, even for temp files. Care should be taken when handling the events. Make sure to only process what you need. For instance, you should check against temp-files, and skip those events. Example:
+Feather Watch will receive very many file events, even for temp files. Care should be taken when handling the events. Make sure to only process what you need. For instance, you should check against temp-files, and skip those events. Example:
 
 	#black list approach
 	un_accepted_file_types = ["tmp", "cache", "db"]

data/feather_watch.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = FeatherWatch::VERSION
   spec.authors       = ["Stephan Nordnes Eriksen"]
   spec.email         = ["stephanruler@gmail.com"]
-  spec.summary       = %q{Barebones, simple, and fast file system watcher}
+  spec.summary       = %q{Barebones, simple, and fast Ruby file system watcher}
   spec.description   = %q{A barebones file system watcher which uses native file system events for Linux, OSx, and Windows.}
   spec.homepage      = "https://github.com/stephan-nordnes-eriksen/feather_watch"
   spec.license       = "MIT"

data/lib/feather_watch/core/darwin_watcher.rb

@@ -1,7 +1,8 @@
 module FeatherWatch::Core
 	class DarwinWatcher
-		def initialize(directories, callback, verbose= false)
+		def initialize(directories, callback, verbose= false, silence_exceptions= false)
 			@verbose = verbose
+			@silence_exceptions = silence_exceptions
 			puts "Initializing mac watcher" if @verbose
 			@fs_event = FSEvent.new
 			options = { :no_defer => true,
@@ -9,12 +10,21 @@ module FeatherWatch::Core
 
 			@fs_event.watch directories, options do |changed_files|
 				changed_files.each do |f|
-					if File.file?(f)
-						puts "Change on file: #{f}" if @verbose
-						callback.call({status: :modified, file: f})
-					else
-						puts "Removed file: #{f}" if @verbose
-						callback.call({status: :removed, file: f})
+					begin
+						if File.file?(f)
+							puts "Change on file: #{f}" if @verbose
+							callback.call({status: :modified, file: f, event: f})
+						else
+							puts "Removed file: #{f}" if @verbose
+							callback.call({status: :removed, file: f, event: f})
+						end
+					rescue Exception => e
+						unless @silence_exceptions
+							STDERR.puts "----------------------------"
+							STDERR.puts "Error in Feather Watch callback"
+							STDERR.puts "Message: #{e.message}"
+							STDERR.puts "backtrace: #{e.backtrace * "\n\t >"}"
+						end
 					end
 				end
 			end

data/lib/feather_watch/core/linux_watcher.rb

@@ -1,33 +1,44 @@
 module FeatherWatch::Core
 	class LinuxWatcher
-		def initialize(directories, callback, verbose= false)
+		def initialize(directories, callback, verbose= false, silence_exceptions= false)
 			@verbose = verbose
+			@silence_exceptions = silence_exceptions
 			puts "Initializing linux watcher" if @verbose
 			@notifiers = []
+			directories = [directories] if directories.is_a?(String)
 			directories.each do |dir|
 				notifier = INotify::Notifier.new
 				@notifiers << notifier
 				#Avaliable events: :access, :attrib, :close_write, :close_nowrite, :create, :delete, :delete_self, :ignored, :modify, :move_self, :moved_from, :moved_to, :open
-				notifier.watch(dir, :create, :attrib, :delete, :close_write, :delete_self, :modify, :move_self, :moved_from, :moved_to) do |event|
+				notifier.watch(dir, :recursive, :create, :attrib, :delete, :close_write, :delete_self, :modify, :move_self, :moved_from, :moved_to) do |event|
 					#TODO: This information is probably in the event, but I'm on a mac now, so I can't test it properly
 					
-					if    !([:attrib, :close_write, :modify] & event.flags ).empty?
-					puts "Change on file: #{event.absolute_name}" if @verbose
-						callback.call({status: :modified, file: event.absolute_name})
-					elsif !([:moved_to]                      & event.flags ).empty?
-						puts "File added: #{event.absolute_name}"     if @verbose
-						callback.call({status: :added, file: event.absolute_name})
-					elsif !([:moved_from]                    & event.flags ).empty?
-						puts "File removed: #{event.absolute_name}"   if @verbose
-						callback.call({status: :removed, file: event.absolute_name})
-					elsif !([:create]                        & event.flags ).empty?
-						puts "File added: #{event.absolute_name}"     if @verbose
-						callback.call({status: :added, file: event.absolute_name})
-					elsif !([:delete, :delete_self]          & event.flags ).empty?
-						puts "File removed: #{event.absolute_name}"   if @verbose
-						callback.call({status: :removed, file: event.absolute_name})
-					else
-						puts "Unhandled status flags: #{event.flags} for file #{event.absolute_name}" if @verbose
+					begin
+						if    !([:attrib, :close_write, :modify] & event.flags ).empty?
+							puts "Change on file: #{event.absolute_name}" if @verbose
+							callback.call({status: :modified, file: event.absolute_name, event: event})
+						elsif !([:moved_to]                      & event.flags ).empty?
+							puts "File added: #{event.absolute_name}"     if @verbose
+							callback.call({status: :added, file: event.absolute_name, event: event})
+						elsif !([:moved_from]                    & event.flags ).empty?
+							puts "File removed: #{event.absolute_name}"   if @verbose
+							callback.call({status: :removed, file: event.absolute_name, event: event})
+						elsif !([:create]                        & event.flags ).empty?
+							puts "File added: #{event.absolute_name}"     if @verbose
+							callback.call({status: :added, file: event.absolute_name, event: event})
+						elsif !([:delete, :delete_self]          & event.flags ).empty?
+							puts "File removed: #{event.absolute_name}"   if @verbose
+							callback.call({status: :removed, file: event.absolute_name, event: event})
+						else
+							STDERR.puts "Unhandled status flags: #{event.flags} for file #{event.absolute_name}" if @verbose
+						end
+					rescue Exception => e
+						unless @silence_exceptions
+							STDERR.puts "----------------------------"
+							STDERR.puts "Error in Feather Watch callback"
+							STDERR.puts "Message: #{e.message}"
+							STDERR.puts "backtrace: #{e.backtrace * "\n\t >"}"
+						end
 					end
 				end
 			end

data/lib/feather_watch/core/windows_watcher.rb

@@ -1,27 +1,38 @@
 module FeatherWatch::Core
 	class WindowsWatcher
-		def initialize(directories, callback, verbose= false)
+		def initialize(directories, callback, verbose= false, silence_exceptions= false)
 			@verbose = verbose
+			@silence_exceptions = silence_exceptions
 			puts "Initializing windows watcher" if @verbose
 			@monitors = []
+			directories = [directories] if directories.is_a?(String)
 			directories.each do |dir|
 				monitor = WDM::Monitor.new
 				@monitors << monitor
 				monitor.watch_recursively(dir, :files) do |change|
 					#TODO: Have not tested this. It should work
 
-					case change.type
-					when :added, :renamed_new_file
-						puts "File added: #{change.path}" if @verbose
-						callback.call({status: :added, file: change.path})
-					when :removed, :renamed_old_file
-						puts "Removed file: #{change.path}" if @verbose
-						callback.call({status: :removed, file: change.path})
-					when :modified, :attrib
-						puts "File modified: #{change.path}" if @verbose
-						callback.call({status: :modified, file: change.path})
-					else
-						puts "Unhandled status type: #{change.type} for file #{change.path}" if @verbose
+					begin
+						case change.type
+						when :added, :renamed_new_file
+							puts "File added: #{change.path}" if @verbose
+							callback.call({status: :added, file: change.path, event: change})
+						when :removed, :renamed_old_file
+							puts "Removed file: #{change.path}" if @verbose
+							callback.call({status: :removed, file: change.path, event: change})
+						when :modified, :attrib
+							puts "File modified: #{change.path}" if @verbose
+							callback.call({status: :modified, file: change.path, event: change})
+						else
+							STDERR.puts "Unhandled status type: #{change.type} for file #{change.path}" if @verbose
+						end	
+					rescue Exception => e
+						unless @silence_exceptions
+							STDERR.puts "----------------------------"
+							STDERR.puts "Error in Feather Watch callback"
+							STDERR.puts "Message: #{e.message}"
+							STDERR.puts "backtrace: #{e.backtrace * "\n\t >"}"
+						end
 					end
 				end	
 			end

data/lib/feather_watch/version.rb

@@ -1,3 +1,3 @@
 module FeatherWatch
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/feather_watch/watcher.rb

@@ -12,15 +12,19 @@ module FeatherWatch
 		#   FeatherWatch::Watcher.new([File.join(Dir.home, 'Desktop')], lambda{|e| puts "got event with status: #{e[:status]} on file #{e[:file]}"})
 		#
 		# Returns a Watcher object.
-		def initialize(directories, callback, verbose= false)
+		def initialize(directories, callback, verbose= false, silence_exceptions= false)
 			@verbose = verbose
 			dir = directories
 			dir = [directories] if directories.is_a?(String)
 			raise "Unknown datatype for directories. Was: #{dir}" unless dir.is_a?(Array)
 
-			@listener = FeatherWatch::Core::DarwinWatcher.new(dir, callback, verbose)  if FeatherWatch::OS.mac?
-			@listener = FeatherWatch::Core::LinuxWatcher.new(dir, callback, verbose)   if FeatherWatch::OS.linux?
-			@listener = FeatherWatch::Core::WindowsWatcher.new(dir, callback, verbose) if FeatherWatch::OS.windows?
+			dir.each do |d|
+				raise "Not a vaild directory: #{d}" unless File.directory?(d)
+			end
+
+			@listener = FeatherWatch::Core::DarwinWatcher.new(dir, callback, verbose, silence_exceptions)  if FeatherWatch::OS.mac?
+			@listener = FeatherWatch::Core::LinuxWatcher.new(dir, callback, verbose, silence_exceptions)   if FeatherWatch::OS.linux?
+			@listener = FeatherWatch::Core::WindowsWatcher.new(dir, callback, verbose, silence_exceptions) if FeatherWatch::OS.windows?
 		end
 
 		# Public: Starts the watcher.

data/spec/lib/feather_watch/core/darwin_watcher_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+class FSEvent
+end
+
+describe FeatherWatch::Core::DarwinWatcher do
+	after(:each) do
+		FileUtils.rm_rf(File.join(Dir.pwd, "test_folder"))
+	end
+	describe ".initialize" do
+		it "catches exceptions in user callback and print to STDERR" do
+			fse_spy = spy("FSEvent spy")
+			expect(FSEvent).to receive(:new).and_return(fse_spy)
+			
+			path = File.join(Dir.pwd, "test_folder")
+			file_path = File.join(Dir.pwd, "test_folder", "new_file")
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = false
+
+			the_callback = nil
+			expect(fse_spy).to receive(:watch) do |watch_paths, options=nil, &block|
+				the_callback = block
+				expect(watch_paths).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path, event: anything}).and_raise("some error")
+			expect(STDERR).to receive(:puts).exactly(4).times.with(kind_of(String))
+
+
+			watcher = FeatherWatch::Core::DarwinWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			expect{the_callback.call([file_path])}.to_not raise_error
+
+			watcher.stop
+		end
+		it "executes callback with :removed if file does not exist" do
+			fse_spy = spy("FSEvent spy")
+			expect(FSEvent).to receive(:new).and_return(fse_spy)
+			
+			path = File.join(Dir.pwd, "test_folder")
+			file_path = File.join(Dir.pwd, "test_folder", "new_file")
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(fse_spy).to receive(:watch) do |watch_paths, options=nil, &block|
+				the_callback = block
+				expect(watch_paths).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+
+
+			watcher = FeatherWatch::Core::DarwinWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			expect{the_callback.call([file_path])}.to_not raise_error
+
+			watcher.stop
+		end
+
+		it "executes callback with :modified if file exist" do
+			fse_spy = spy("FSEvent spy")
+			expect(FSEvent).to receive(:new).and_return(fse_spy)
+			
+			path = File.join(Dir.pwd, "test_folder")
+			file_path = File.join(Dir.pwd, "test_folder", "new_file")
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(fse_spy).to receive(:watch) do |watch_paths, options=nil, &block|
+				the_callback = block
+				expect(watch_paths).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :modified ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			FileUtils.mkdir(path)
+			FileUtils.touch(file_path)
+			sleep 0.1
+
+			watcher = FeatherWatch::Core::DarwinWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			expect{the_callback.call([file_path])}.to_not raise_error
+
+			watcher.stop
+		end
+	end
+
+end

data/spec/lib/feather_watch/core/linux_watcher_spec.rb

@@ -0,0 +1,396 @@
+require 'spec_helper'
+
+module INotify
+end
+class INotify::Notifier
+end
+
+describe FeatherWatch::Core::LinuxWatcher do
+	
+	let(:path)       {File.join(Dir.pwd, "test_folder")}
+	let(:file_path)  {File.join(Dir.pwd, "test_folder", "new_file")}
+
+	after(:each) do
+		FileUtils.rm_rf(File.join(Dir.pwd, "test_folder"))
+	end
+	describe ".initialize" do
+		it "catches exceptions in user callback and print to STDERR" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = false
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path, event: anything}).and_raise("some error")
+			expect(STDERR).to receive(:puts).exactly(4).times.with(kind_of(String))
+
+
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:delete])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			expect{the_callback.call(event_spy)}.to_not raise_error
+
+			watcher.stop
+		end
+		it "executes callback with :removed if file does not exist" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+
+
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:delete])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			expect{the_callback.call(event_spy)}.to_not raise_error
+
+			watcher.stop
+		end
+
+		it "executes callback with :modified if file exist" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :added ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:create])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			expect{the_callback.call(event_spy)}.to_not raise_error
+
+			watcher.stop
+		end
+
+
+
+		it "inotify-event with :attrib produces :modified FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :modified ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:attrib])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+		it "inotify-event with :close_write produces :modified FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :modified ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:close_write])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+		it "inotify-event with :modify produces :modified FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :modified ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:modify])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+		
+
+		it "inotify-event with :moved_to produces :added FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :added ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:moved_to])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+
+		it "inotify-event with :moved_from produces :removed FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:moved_from])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+
+		it "inotify-event with :create produces :added FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :added ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:create])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+
+		it "inotify-event with :delete produces :removed FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:delete])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+		it "inotify-event with :delete_self produces :removed FeatherWatch-event" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path, event: anything})
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([:delete_self])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+
+		it "Prints error to STDERR when no event flags and verbose" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			allow(STDOUT).to receive(:puts)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = true
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to_not receive(:call)
+			expect(STDERR).to receive(:puts).exactly(1).times.with(kind_of(String))
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+		it "Does not print to STDERR when no event flags and not verbose" do
+			inotify_spy = spy("inotify spy")
+			expect(INotify::Notifier).to receive(:new).and_return(inotify_spy)
+			
+			callback_spy = spy("Callback Spy")
+			verbose = false
+			silence_exceptions = true
+
+			the_callback = nil
+			expect(inotify_spy).to receive(:watch) do |watch_path, *flags, &callback|
+				the_callback = callback
+				expect(watch_path).to eq(path)
+			end
+
+
+			expect(callback_spy).to_not receive(:call)
+			expect(STDERR).to_not receive(:puts)
+			
+			watcher = FeatherWatch::Core::LinuxWatcher.new(path,callback_spy,verbose, silence_exceptions)
+			watcher.start
+			
+			event_spy = spy("Event spy")
+			allow(event_spy).to receive(:flags).and_return([])
+			allow(event_spy).to receive(:absolute_name).and_return(file_path)
+			the_callback.call(event_spy)
+
+			watcher.stop
+		end
+	end
+
+end