feather_watch 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c365a117cc400f3b83860aabf245dbdd24a87d0e
+  data.tar.gz: e37efc790a575ed9c9beb2f2699d6e4eff745fbd
+SHA512:
+  metadata.gz: 54894b9dc54e207f0afc675e75ceddcfb036bfa502d55bbef66fdfcc25b647e5ab85e86807c9a6783d04f8aeaea2868cf61ee4994043ebcbef77372b767f144d
+  data.tar.gz: 5ccbdba157e5c9cab6cfd23e4033a837259975a81e1cefa0cf6e6900f1543e637f822f90db76cbe0bf8b15bb8b6309521350953484406650548bcec5b0484ef0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,18 @@
+gemfile:
+- Gemfile
+language: ruby
+rvm:
+- 2.0.0
+- 2.1.0
+- 2.1.1
+- 2.1.2
+- 2.1.3
+matrix:
+  allow_failures:
+  - rvm: 1.8.7
+  - rvm: 1.9.2
+  - rvm: 1.9.3
+  - rvm: jruby-head
+  - rvm: ruby-head
+  - rvm: rbx
+  fast_finish: true

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in feather_watch.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Stephan Nordnes Eriksen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+![Feather Watch](/Feather Watch.png?raw=true)
+
+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 :)
+
+[![Build Status](https://travis-ci.org/stephan-nordnes-eriksen/feather_watch.svg?branch=master)](https://travis-ci.org/stephan-nordnes-eriksen/feather_watch)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'feather_watch'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install feather_watch
+
+## Usage
+
+	require "feather_watch"
+	callback = lambda{|e| puts "Event #{e[:status]} on file #{e[:file]}"}
+	paths_to_watch = "/" #can be a string or array of string, eg: ["/home/data", "/home/pictures"]
+	watcher = FeatherWatch.new(paths_to_watch, callback)
+	watcher.start #non-blocking
+
+	#To stop:
+	watcher.stop
+
+### Received statuses
+
+ - :added
+ - :modified
+ - :removed
+
+
+# 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.
+
+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:
+
+	#black list approach
+	un_accepted_file_types = ["tmp", "cache", "db"]
+	callback = lambda{|e| use_event(e) unless un_accepted_file_types.include?(e[:file].split(".")[-1])} 
+
+	#white list approach
+	accepted_file_types = ["png", "jpg", "jpeg", "gif"]
+	callback = lambda{|e| use_event(e) if accepted_file_types.include?(e[:file].split(".")[-1])}
+
+You need to take care to filter out what you do not need for each target platform. 
+
+
+
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/feather_watch/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rubygems"
+Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+task :test => :spec

data/feather_watch.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'feather_watch/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "feather_watch"
+  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.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"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rb-fsevent', '~> 0.9'
+  spec.add_dependency 'rb-inotify', '~> 0.9'
+  spec.add_dependency 'wdm', '~> 0.1'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "rake"
+end

data/lib/feather_watch.rb

@@ -0,0 +1,17 @@
+require "feather_watch/version"
+require "feather_watch/os"
+require "feather_watch/watcher"
+require "feather_watch/core/darwin_watcher"
+require "feather_watch/core/linux_watcher"
+require "feather_watch/core/windows_watcher"
+
+
+require 'rb-fsevent' if FeatherWatch::OS.mac?
+require 'rb-inotify' if FeatherWatch::OS.linux?
+require 'wdm'        if FeatherWatch::OS.windows?
+
+module FeatherWatch
+	def self.new(*args)
+		FeatherWatch::Watcher.new(*args)
+	end
+end

data/lib/feather_watch/core/darwin_watcher.rb

@@ -0,0 +1,35 @@
+module FeatherWatch::Core
+	class DarwinWatcher
+		def initialize(directories, callback, verbose= false)
+			@verbose = verbose
+			puts "Initializing mac watcher" if @verbose
+			@fs_event = FSEvent.new
+			options = { :no_defer => true,
+						:file_events => true }
+
+			@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})
+					end
+				end
+			end
+		end
+		
+		def start
+			puts "Starting mac watcher" if @verbose
+			Thread.new do
+				@fs_event.run
+			end
+		end
+
+		def stop
+			puts "Stopping mac watcher" if @verbose
+			@fs_event.stop
+		end
+	end
+end

data/lib/feather_watch/core/linux_watcher.rb

@@ -0,0 +1,52 @@
+module FeatherWatch::Core
+	class LinuxWatcher
+		def initialize(directories, callback, verbose= false)
+			@verbose = verbose
+			puts "Initializing linux watcher" if @verbose
+			@notifiers = []
+			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|
+					#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
+					end
+				end
+			end
+		end
+		
+		def start
+			puts "Starting linux watcher" if @verbose
+			@notifiers.each do |notifier|
+				Thread.new do
+					notifier.run
+				end
+			end
+		end
+
+		def stop
+			puts "Stopping linux watcher" if @verbose
+			@notifiers.each do |notifier|
+				notifier.stop
+			end
+		end
+	end
+end

data/lib/feather_watch/core/windows_watcher.rb

@@ -0,0 +1,46 @@
+module FeatherWatch::Core
+	class WindowsWatcher
+		def initialize(directories, callback, verbose= false)
+			@verbose = verbose
+			puts "Initializing windows watcher" if @verbose
+			@monitors = []
+			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
+					end
+				end	
+			end
+		end
+		
+		def start
+			puts "Starting windows watcher" if @verbose
+			@monitors.each do |monitor|
+				Thread.new do
+					monitor.run!
+				end
+			end
+		end
+
+		def stop
+			puts "Stopping windows watcher" if @verbose
+			@monitors.each do |monitor|
+				monitor.stop
+			end
+		end
+	end
+end

data/lib/feather_watch/os.rb

@@ -0,0 +1,17 @@
+module FeatherWatch::OS
+  def self.windows?
+    (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+  end
+
+  def self.mac?
+   (/darwin/ =~ RUBY_PLATFORM) != nil
+  end
+
+  def self.unix?
+    !self.windows?
+  end
+
+  def self.linux?
+    self.unix? and not self.mac?
+  end
+end

data/lib/feather_watch/version.rb

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

data/lib/feather_watch/watcher.rb

@@ -0,0 +1,50 @@
+module FeatherWatch
+	class Watcher
+
+		# Public: Initialize the file system watcher. 
+		#
+		# directories  - An array of directories to watch.
+		# callback - A callback that will receive events. Recieved objects on form: {status: [:modified, :removed].sample, file: "path/to/file"}. ":modified" means everything except deleted.
+		# verbose=false - Enable verbose mode. Warning: Can produce very much output
+		#
+		# Examples
+		#
+		#   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)
+			@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?
+		end
+
+		# Public: Starts the watcher.
+		#
+		# Examples
+		#
+		#   watcher.start
+		#   # => nil
+		#
+		# Returns nil
+		def start
+			@listener.start if @listener
+		end
+
+		# Public: Stops the watcher.
+		#
+		# Examples
+		#
+		#   watcher.start
+		#   # => nil
+		#
+		# Returns nil
+		def stop
+			@listener.stop if @listener
+		end
+	end
+end

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

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+
+describe FeatherWatch::Watcher do
+	describe ".initialize" do
+		it "does not crash" do
+			expect{FeatherWatch::Watcher.new("/",lambda { |e|  })}.to_not raise_error
+			expect{FeatherWatch::Watcher.new("/",lambda { |e|  }, false)}.to_not raise_error
+		end
+		it "calls DarwinWatcher.new on darwin" do
+			allow(Kernel).to receive(:require).with('rb-fsevent')
+			allow(FeatherWatch::OS).to receive(:mac?)      {true}
+			allow(FeatherWatch::OS).to receive(:linux?)    {false}
+			allow(FeatherWatch::OS).to receive(:windows?)  {false}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			expect(FeatherWatch::Core::DarwinWatcher).to receive(:new).with([path],callback,verbose)
+			
+			FeatherWatch::Watcher.new(path,callback,verbose)
+		end
+		it "calls LinuxWatcher.new on linux" do
+			allow(Kernel).to receive(:require).with('rb-inotify')
+			allow(FeatherWatch::OS).to receive(:mac?)      {false}
+			allow(FeatherWatch::OS).to receive(:linux?)    {true}
+			allow(FeatherWatch::OS).to receive(:windows?)  {false}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			expect(FeatherWatch::Core::LinuxWatcher).to receive(:new).with([path],callback,verbose)
+			
+			FeatherWatch::Watcher.new(path,callback,verbose)
+		end
+		it "calls WindowsWatcher.new on windows" do
+			allow(Kernel).to receive(:require).with('wdm')
+			allow(FeatherWatch::OS).to receive(:mac?)      {false}
+			allow(FeatherWatch::OS).to receive(:linux?)    {false}
+			allow(FeatherWatch::OS).to receive(:windows?)  {true}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			expect(FeatherWatch::Core::WindowsWatcher).to receive(:new).with([path],callback,verbose)
+			
+			FeatherWatch::Watcher.new(path,callback,verbose)
+		end
+	end
+
+	describe ".start" do
+		it "calls start on a DarwinWatcher on darwin" do
+			allow(Kernel).to receive(:require).with('rb-fsevent')
+			allow(FeatherWatch::OS).to receive(:mac?)      {true}
+			allow(FeatherWatch::OS).to receive(:linux?)    {false}
+			allow(FeatherWatch::OS).to receive(:windows?)  {false}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			darwin_spy = spy "DarwinWatcher"
+			expect(FeatherWatch::Core::DarwinWatcher).to receive(:new).with([path],callback,verbose) {darwin_spy}
+			expect(darwin_spy).to receive(:start)
+			FeatherWatch::Watcher.new(path,callback,verbose).start
+		end
+		it "calls start on a LinuxWatcher on linux" do
+			allow(Kernel).to receive(:require).with('rb-inotify')
+			allow(FeatherWatch::OS).to receive(:mac?)      {false}
+			allow(FeatherWatch::OS).to receive(:linux?)    {true}
+			allow(FeatherWatch::OS).to receive(:windows?)  {false}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			linux_spy = spy "LinuxWatcher"
+			expect(FeatherWatch::Core::LinuxWatcher).to receive(:new).with([path],callback,verbose) {linux_spy}
+			expect(linux_spy).to receive(:start)
+			FeatherWatch::Watcher.new(path,callback,verbose).start
+		end
+		it "calls start on a WindowsWatcher on windows" do
+			allow(Kernel).to receive(:require).with('wdm')
+			allow(FeatherWatch::OS).to receive(:mac?)      {false}
+			allow(FeatherWatch::OS).to receive(:linux?)    {false}
+			allow(FeatherWatch::OS).to receive(:windows?)  {true}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			windows_spy = spy "WindowsWatcher"
+			expect(FeatherWatch::Core::WindowsWatcher).to receive(:new).with([path],callback,verbose) {windows_spy}
+			expect(windows_spy).to receive(:start)
+			FeatherWatch::Watcher.new(path,callback,verbose).start
+		end
+	end
+
+	describe ".stop" do
+		it "calls stop on a DarwinWatcher on darwin" do
+			allow(Kernel).to receive(:require).with('rb-fsevent')
+			allow(FeatherWatch::OS).to receive(:mac?)      {true}
+			allow(FeatherWatch::OS).to receive(:linux?)    {false}
+			allow(FeatherWatch::OS).to receive(:windows?)  {false}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			darwin_spy = spy "DarwinWatcher"
+			expect(FeatherWatch::Core::DarwinWatcher).to receive(:new).with([path],callback,verbose) {darwin_spy}
+			expect(darwin_spy).to receive(:stop)
+			FeatherWatch::Watcher.new(path,callback,verbose).stop
+		end
+		it "calls stop on a LinuxWatcher on linux" do
+			allow(Kernel).to receive(:require).with('rb-inotify')
+			allow(FeatherWatch::OS).to receive(:mac?)      {false}
+			allow(FeatherWatch::OS).to receive(:linux?)    {true}
+			allow(FeatherWatch::OS).to receive(:windows?)  {false}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			linux_spy = spy "LinuxWatcher"
+			expect(FeatherWatch::Core::LinuxWatcher).to receive(:new).with([path],callback,verbose) {linux_spy}
+			expect(linux_spy).to receive(:stop)
+			FeatherWatch::Watcher.new(path,callback,verbose).stop
+		end
+		it "calls stop on a WindowsWatcher on windows" do
+			allow(Kernel).to receive(:require).with('wdm')
+			allow(FeatherWatch::OS).to receive(:mac?)      {false}
+			allow(FeatherWatch::OS).to receive(:linux?)    {false}
+			allow(FeatherWatch::OS).to receive(:windows?)  {true}
+			allow(FeatherWatch::OS).to receive(:unix?)     {false}
+			
+			path = "/"
+			callback = lambda { |e|  }
+			verbose = false
+
+			windows_spy = spy "WindowsWatcher"
+			expect(FeatherWatch::Core::WindowsWatcher).to receive(:new).with([path],callback,verbose) {windows_spy}
+			expect(windows_spy).to receive(:stop)
+			FeatherWatch::Watcher.new(path,callback,verbose).stop
+		end
+	end
+end

data/spec/lib/feather_watch/feather_watch_spec.rb

@@ -0,0 +1,81 @@
+describe FeatherWatch do
+	before(:each) do
+		FileUtils.mkdir(File.join(Dir.pwd, "test_folder"))
+	end
+	after(:each) do
+		FileUtils.rm_rf(File.join(Dir.pwd, "test_folder"))
+	end
+
+	it "passen self.new on to FeatherWatch::Watcher" do
+		args = ["/",lambda { |e|  }, false]
+		expect(FeatherWatch::Watcher).to receive(:new).with(*args)
+		FeatherWatch.new(*args)
+	end
+	#These tests are platform dependent and should be run once on windows, darwin, and linux
+	#This test is also prone to sporadic failures.
+	it "returns correct file path and status when file is added" do
+		path = File.join(Dir.pwd, "test_folder")
+		callback_spy = spy("Callback Spy")
+		verbose = false
+		
+		file_path = File.join(Dir.pwd, "test_folder", "new_file")
+
+		if FeatherWatch::OS.mac?
+			expect(callback_spy).to receive(:call).with({status: :modified ,file: file_path})
+		else
+			expect(callback_spy).to receive(:call).with({status: :added ,file: file_path}) 
+		end
+
+		watcher = FeatherWatch::Watcher.new(path,callback_spy,verbose)
+		watcher.start
+		sleep 0.1 #need to wait for watcher to properly start
+		FileUtils.touch(file_path)
+		sleep 0.1 #need to wait for file event to propegate.
+		watcher.stop
+	end
+
+	it "returns correct file path and status when file is removed" do
+		path = File.join(Dir.pwd, "test_folder")
+		callback_spy = spy("Callback Spy")
+		verbose = false
+		
+		file_path = File.join(Dir.pwd, "test_folder", "new_file")
+		FileUtils.touch(file_path)
+		sleep 0.1 
+		expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path})
+
+		watcher = FeatherWatch::Watcher.new(path,callback_spy,verbose)
+		watcher.start
+		sleep 0.1 #need to wait for watcher to properly start
+		FileUtils.rm(file_path)
+		sleep 0.1 #need to wait for file event to propegate.
+		watcher.stop
+	end
+
+	it "returns correct file path and status when file is moved" do
+		path = File.join(Dir.pwd, "test_folder")
+		callback_spy = spy("Callback Spy")
+		verbose = false
+		
+		file_path = File.join(Dir.pwd, "test_folder", "new_file")
+		file_path_new = File.join(Dir.pwd, "test_folder", "new_file_new")
+
+		FileUtils.touch(file_path)
+		sleep 0.1 
+		
+		expect(callback_spy).to receive(:call).with({status: :removed ,file: file_path})
+		if FeatherWatch::OS.mac?
+			expect(callback_spy).to receive(:call).with({status: :modified ,file: file_path_new})
+		else
+			expect(callback_spy).to receive(:call).with({status: :added ,file: file_path_new}) 
+		end
+
+		watcher = FeatherWatch::Watcher.new(path,callback_spy,verbose)
+		watcher.start
+		sleep 0.1 #need to wait for watcher to properly start
+		FileUtils.mv(file_path, file_path_new)
+		sleep 0.1 #need to wait for file event to propegate.
+		watcher.stop
+	end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,110 @@
+#START: HACK TO GET TRAVIS TO FAIL CORRECTLY WHEN SPECS FAIL:
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
+  module Kernel
+    alias :__at_exit :at_exit
+    def at_exit(&block)
+      __at_exit do
+        exit_status = $!.status if $!.is_a?(SystemExit)
+        block.call
+        exit exit_status if exit_status
+      end
+    end
+  end
+end
+#END
+
+require 'simplecov'
+SimpleCov.start
+
+require "feather_watch"
+require "fileutils"
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: feather_watch
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stephan Nordnes Eriksen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: wdm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A barebones file system watcher which uses native file system events
+  for Linux, OSx, and Windows.
+email:
+- stephanruler@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Feather Watch.png
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- feather_watch.gemspec
+- lib/feather_watch.rb
+- lib/feather_watch/core/darwin_watcher.rb
+- lib/feather_watch/core/linux_watcher.rb
+- lib/feather_watch/core/windows_watcher.rb
+- lib/feather_watch/os.rb
+- lib/feather_watch/version.rb
+- lib/feather_watch/watcher.rb
+- spec/lib/feather_watch/core/watcher_spec.rb
+- spec/lib/feather_watch/feather_watch_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/stephan-nordnes-eriksen/feather_watch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Barebones, simple, and fast file system watcher
+test_files:
+- spec/lib/feather_watch/core/watcher_spec.rb
+- spec/lib/feather_watch/feather_watch_spec.rb
+- spec/spec_helper.rb
+has_rdoc: