rb-inotify 0.8.8 → 0.10.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 803cf77fe31e9334147381cbc2fcdc911f5c8c060582af70afb80ba00caa4967
+  data.tar.gz: dc13bce654e7a7c20d17722db4a62d4a091a6f21918e8133702306d90d5e0ccb
+SHA512:
+  metadata.gz: 8b798f26a05bb0757e2bb29c49bdc07b694659c9bfd1a007be3fec48acbfccb59c049bbf17881c739f80f66fc63b03df15fb70574aaae73ce2f457667e726eec
+  data.tar.gz: c29ccd96375401b43d52ca09345ab235e11b044706ef4995525372961b126d4b845ac468c422c40dd77eec36995ac19855dccab85706a6458f34505bec5ac02b

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.tags*
+.rspec_status
+/guard/
+/listen/

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+cache: bundler
+
+matrix:
+  include:
+    - rvm: 2.3
+    - rvm: 2.4
+    - rvm: 2.5
+    - rvm: 2.6
+    - rvm: jruby
+    - rvm: truffleruby
+    - rvm: jruby-head
+    - rvm: ruby-head
+  allow_failures:
+    - rvm: truffleruby
+    - rvm: jruby
+    - rvm: ruby-head
+    - rvm: jruby-head
+  fast_finish: true

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in utopia.gemspec
+gemspec
+
+group :development do
+	gem 'pry'
+	gem 'pry-coolline'
+	
+	gem 'tty-prompt'
+end
+
+group :test do
+	gem 'simplecov'
+	gem 'coveralls', require: false
+end

data/LICENSE.md

@@ -0,0 +1,10 @@
+# The MIT License
+
+Copyright, 2009, by [Natalie Weizenbaum](https://github.com/nex3).  
+Copyright, 2017, by [Samuel G. D. Williams](http://www.codeotaku.com).  
+
+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

@@ -6,7 +6,11 @@ It uses the [FFI](http://wiki.github.com/ffi/ffi) gem to avoid having to compile
 
 [API documentation is available on rdoc.info](http://rdoc.info/projects/nex3/rb-inotify).
 
-## Basic Usage
+[![Build Status](https://secure.travis-ci.org/guard/rb-inotify.svg)](http://travis-ci.org/guard/rb-inotify)
+[![Code Climate](https://codeclimate.com/github/guard/rb-inotify.svg)](https://codeclimate.com/github/guard/rb-inotify)
+[![Coverage Status](https://coveralls.io/repos/guard/rb-inotify/badge.svg)](https://coveralls.io/r/guard/rb-inotify)
+
+## Usage
 
 The API is similar to the inotify C API, but with a more Rubyish feel.
 First, create a notifier:
@@ -64,3 +68,46 @@ It can even be used with EventMachine:
 Unfortunately, this currently doesn't work under JRuby.
 JRuby currently doesn't use native file descriptors for the IO object,
 so we can't use the notifier's file descriptor as a stand-in.
+
+### Resource Limits
+
+If you get an error like `inotify event queue has overflowed` you might be running into system limits. You can add the following to your `/etc/sysctl.conf` to increase the number of files that can be monitored:
+
+```
+fs.inotify.max_user_watches = 100000
+fs.inotify.max_queued_events = 100000
+fs.inotify.max_user_instances = 100000
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request
+
+## License
+
+Released under the MIT license.
+
+Copyright, 2009, by [Natalie Weizenbaum](https://github.com/nex3).
+Copyright, 2017, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
+
+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/Rakefile

@@ -1,54 +1,14 @@
-require 'rubygems'
-require 'rake'
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "rb-inotify"
-    gem.summary = "A Ruby wrapper for Linux's inotify, using FFI"
-    gem.description = gem.summary
-    gem.email = "nex342@gmail.com"
-    gem.homepage = "http://github.com/nex3/rb-inotify"
-    gem.authors = ["Nathan Weizenbaum"]
-    gem.add_dependency "ffi", ">= 0.5.0"
-    gem.add_development_dependency "yard", ">= 0.4.0"
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-task(:permissions) {sh %{chmod -R a+r .}}
-Rake::Task[:build].prerequisites.unshift('permissions')
+RSpec::Core::RakeTask.new(:spec)
 
-module Jeweler::VersionHelper::PlaintextExtension
-  def write_with_inotify
-    write_without_inotify
-    filename = File.join(File.dirname(__FILE__), "lib/rb-inotify.rb")
-    text = File.read(filename)
-    File.open(filename, 'w') do |f|
-      f.write text.gsub(/^(  VERSION = ).*/, '\1' + [major, minor, patch].inspect)
-    end
-  end
-  alias_method :write_without_inotify, :write
-  alias_method :write, :write_with_inotify
-end
-
-class Jeweler::Commands::Version::Base
-  def commit_version_with_inotify
-    return unless self.repo
-    self.repo.add(File.join(File.dirname(__FILE__), "lib/rb-inotify.rb"))
-    commit_version_without_inotify
-  end
-  alias_method :commit_version_without_inotify, :commit_version
-  alias_method :commit_version, :commit_version_with_inotify
-end
+desc "Run tests"
+task :default => :spec
 
-begin
-  require 'yard'
-  YARD::Rake::YardocTask.new
-rescue LoadError
-  task :yardoc do
-    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
-  end
+task :console do
+  require 'rb-inotify'
+  require 'pry'
+  
+  binding.pry
 end

data/lib/rb-inotify/errors.rb

@@ -0,0 +1,3 @@
+module INotify
+  class QueueOverflowError < RuntimeError; end
+end

data/lib/rb-inotify/event.rb

@@ -113,11 +113,11 @@ module INotify
       @native = Native::Event.new(ptr)
       @related = []
       @cookie = @native[:cookie]
-      @name = data[@native.size, @native[:len]].gsub(/\0+$/, '')
+      @name = fix_encoding(data[@native.size, @native[:len]].gsub(/\0+$/, ''))
       @notifier = notifier
       @watcher_id = @native[:wd]
 
-      raise Exception.new("inotify event queue has overflowed.") if @native[:mask] & Native::Flags::IN_Q_OVERFLOW != 0
+      raise QueueOverflowError.new("inotify event queue has overflowed.") if @native[:mask] & Native::Flags::IN_Q_OVERFLOW != 0
     end
 
     # Calls the callback of the watcher that fired this event,
@@ -125,7 +125,7 @@ module INotify
     #
     # @private
     def callback!
-      watcher.callback!(self)
+      watcher && watcher.callback!(self)
     end
 
     # Returns the size of this event object in bytes,
@@ -135,5 +135,12 @@ module INotify
     def size
       @native.size + @native[:len]
     end
+
+    private
+
+    def fix_encoding(name)
+      name.force_encoding('filesystem') if name.respond_to?(:force_encoding)
+      name
+    end
   end
 end

data/lib/rb-inotify/native/flags.rb

@@ -65,6 +65,11 @@ module INotify
       # Event occurred against dir.
       IN_ISDIR = 0x40000000
 
+      ## fpathconf Macros
+
+      # returns the maximum length of a filename in the directory path or fd that the process is allowed to create.  The corresponding macro is _POSIX_NAME_MAX.
+      PC_NAME_MAX = 3
+
       # Converts a list of flags to the bitmask that the C API expects.
       #
       # @param flags [Array<Symbol>]

data/lib/rb-inotify/native.rb

@@ -8,7 +8,11 @@ module INotify
   # @private
   module Native
     extend FFI::Library
-    ffi_lib "c"
+    ffi_lib FFI::Library::LIBC
+    begin
+      ffi_lib 'inotify'
+    rescue LoadError
+    end
 
     # The C struct describing an inotify event.
     #
@@ -24,8 +28,6 @@ module INotify
     attach_function :inotify_init, [], :int
     attach_function :inotify_add_watch, [:int, :string, :uint32], :int
     attach_function :inotify_rm_watch, [:int, :uint32], :int
-
-    attach_function :read, [:int, :pointer, :size_t], :ssize_t
-    attach_function :close, [:int], :int
+    attach_function :fpathconf, [:int, :int], :long
   end
 end

data/lib/rb-inotify/notifier.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module INotify
   # Notifier wraps a single instance of inotify.
   # It's possible to have more than one instance,
@@ -38,12 +40,8 @@ module INotify
     # (except under JRuby -- see \{#to\_io}).
     #
     # @return [Fixnum]
-    attr_reader :fd
-
-    # @return [Boolean] Whether or not this Ruby implementation supports
-    #   wrapping the native file descriptor in a Ruby IO wrapper.
-    def self.supports_ruby_io?
-      RUBY_PLATFORM !~ /java/
+    def fd
+      @handle.fileno
     end
 
     # Creates a new {Notifier}.
@@ -51,9 +49,22 @@ module INotify
     # @return [Notifier]
     # @raise [SystemCallError] if inotify failed to initialize for some reason
     def initialize
-      @fd = Native.inotify_init
+      @running = Mutex.new
+      @pipe = IO.pipe
+      # JRuby shutdown sometimes runs IO finalizers before all threads finish.
+      if RUBY_ENGINE == 'jruby'
+        @pipe[0].autoclose = false
+        @pipe[1].autoclose = false
+      end
+
       @watchers = {}
-      return unless @fd < 0
+
+      fd = Native.inotify_init
+      unless fd < 0
+        @handle = IO.new(fd)
+        @handle.autoclose = false if RUBY_ENGINE == 'jruby'
+        return
+      end
 
       raise SystemCallError.new(
         "Failed to initialize inotify" +
@@ -82,10 +93,7 @@ module INotify
     # @return [IO] An IO object wrapping the file descriptor
     # @raise [NotImplementedError] if this is being called in JRuby
     def to_io
-      unless self.class.supports_ruby_io?
-        raise NotImplementedError.new("INotify::Notifier#to_io is not supported under JRuby")
-      end
-      @io ||= IO.new(@fd)
+      @handle
     end
 
     # Watches a file or directory for changes,
@@ -189,12 +197,21 @@ module INotify
     def watch(path, *flags, &callback)
       return Watcher.new(self, path, *flags, &callback) unless flags.include?(:recursive)
 
-      Dir.glob(File.join(path, '*'), File::FNM_DOTMATCH).each do |d|
+      dir = Dir.new(path)
+
+      dir.each do |base|
+        d = File.join(path, base)
         binary_d = d.respond_to?(:force_encoding) ? d.dup.force_encoding('BINARY') : d
         next if binary_d =~ /\/\.\.?$/ # Current or parent directory
-        watch(d, *flags, &callback) if !RECURSIVE_BLACKLIST.include?(d) && File.directory?(d)
+        next if RECURSIVE_BLACKLIST.include?(d)
+        next if flags.include?(:dont_follow) && File.symlink?(d)
+        next if !File.directory?(d)
+
+        watch(d, *flags, &callback)
       end
 
+      dir.close
+
       rec_flags = [:create, :moved_to]
       return watch(path, *((flags - [:recursive]) | rec_flags)) do |event|
         callback.call(event) if flags.include?(:all_events) || !(flags & event.flags).empty?
@@ -212,8 +229,14 @@ module INotify
     #
     # @see #process
     def run
-      @stop = false
-      process until @stop
+      @running.synchronize do
+        Thread.current[:INOTIFY_RUN_THREAD] = true
+        @stop = false
+
+        process until @stop
+      end
+    ensure
+      Thread.current[:INOTIFY_RUN_THREAD] = false
     end
 
     # Stop watching for filesystem events.
@@ -221,6 +244,13 @@ module INotify
     # exit out as soon as we finish handling the events.
     def stop
       @stop = true
+      @pipe.last.write "."
+
+      unless Thread.current[:INOTIFY_RUN_THREAD]
+        @running.synchronize do
+          # no-op: we just needed to wait until the lock was available
+        end
+      end
     end
 
     # Blocks until there are one or more filesystem events
@@ -230,30 +260,30 @@ module INotify
     #
     # @see #run
     def process
-      read_events.each {|event| event.callback!}
+      read_events.each do |event|
+        event.callback!
+        event.flags.include?(:ignored) && event.notifier.watchers.delete(event.watcher_id)
+      end
     end
 
     # Close the notifier.
     #
     # @raise [SystemCallError] if closing the underlying file descriptor fails.
     def close
-      return if Native.close(@fd) == 0
-
-      raise SystemCallError.new("Failed to properly close inotify socket" +
-       case FFI.errno
-       when Errno::EBADF::Errno; ": invalid or closed file descriptior"
-       when Errno::EIO::Errno; ": an I/O error occured"
-       end,
-       FFI.errno)
+      stop
+      @handle.close
+      @watchers.clear
     end
 
-    private
-
-    # Blocks until there are one or more filesystem events
-    # that this notifier has watchers registered for.
-    # Once there are events, returns their {Event} objects.
+    # Blocks until there are one or more filesystem events that this notifier
+    # has watchers registered for. Once there are events, returns their {Event}
+    # objects.
+    #
+    # This can return an empty list if the watcher was closed elsewhere.
+    #
+    # {#run} or {#process} are ususally preferable to calling this directly.
     def read_events
-      size = 64 * Native::Event.size
+      size = Native::Event.size + Native.fpathconf(fd, Native::Flags::PC_NAME_MAX) + 1
       tries = 1
 
       begin
@@ -261,48 +291,36 @@ module INotify
       rescue SystemCallError => er
         # EINVAL means that there's more data to be read
         # than will fit in the buffer size
-        raise er unless er.errno == Errno::EINVAL::Errno || tries == 5
+        raise er unless er.errno == Errno::EINVAL::Errno && tries < 5
         size *= 2
         tries += 1
         retry
       end
+      return [] if data.nil?
 
       events = []
       cookies = {}
-      while ev = Event.consume(data, self)
-        events << ev
-        next if ev.cookie == 0
-        cookies[ev.cookie] ||= []
-        cookies[ev.cookie] << ev
+      while event = Event.consume(data, self)
+        events << event
+        next if event.cookie == 0
+        cookies[event.cookie] ||= []
+        cookies[event.cookie] << event
       end
       cookies.each {|c, evs| evs.each {|ev| ev.related.replace(evs - [ev]).freeze}}
       events
     end
 
+    private
+
     # Same as IO#readpartial, or as close as we need.
     def readpartial(size)
-      # Use Ruby's readpartial if possible, to avoid blocking other threads.
-      return to_io.readpartial(size) if self.class.supports_ruby_io?
-
-      tries = 0
-      begin
-        tries += 1
-        buffer = FFI::MemoryPointer.new(:char, size)
-        size_read = Native.read(fd, buffer, size)
-        return buffer.read_string(size_read) if size_read >= 0
-      end while FFI.errno == Errno::EINTR::Errno && tries <= 5
-
-      raise SystemCallError.new("Error reading inotify events" +
-        case FFI.errno
-        when Errno::EAGAIN::Errno; ": no data available for non-blocking I/O"
-        when Errno::EBADF::Errno; ": invalid or closed file descriptor"
-        when Errno::EFAULT::Errno; ": invalid buffer"
-        when Errno::EINVAL::Errno; ": invalid file descriptor"
-        when Errno::EIO::Errno; ": I/O error"
-        when Errno::EISDIR::Errno; ": file descriptor is a directory"
-        else; ""
-        end,
-        FFI.errno)
+      readable, = select([@handle, @pipe.first])
+      return nil if readable.include?(@pipe.first)
+      @handle.readpartial(size)
+    rescue Errno::EBADF
+      # If the IO has already been closed, reading from it will cause
+      # Errno::EBADF.
+      nil
     end
   end
 end

data/lib/rb-inotify/version.rb

@@ -0,0 +1,24 @@
+# Copyright, 2012, by Natalie Weizenbaum.
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# 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.
+
+module INotify
+  VERSION = '0.10.1'
+end

data/lib/rb-inotify/watcher.rb

@@ -45,8 +45,13 @@ module INotify
     #
     # @raise [SystemCallError] if the watch fails to be disabled for some reason
     def close
-      return if Native.inotify_rm_watch(@notifier.fd, @id) == 0
-      raise SystemCallError.new("Failed to stop watching #{path.inspect}", FFI.errno)
+      if Native.inotify_rm_watch(@notifier.fd, @id) == 0
+        @notifier.watchers.delete(@id)
+        return
+      end
+
+      raise SystemCallError.new("Failed to stop watching #{path.inspect}",
+                                FFI.errno)
     end
 
     # Creates a new {Watcher}.

data/lib/rb-inotify.rb

@@ -1,8 +1,10 @@
+require 'rb-inotify/version'
 require 'rb-inotify/native'
 require 'rb-inotify/native/flags'
 require 'rb-inotify/notifier'
 require 'rb-inotify/watcher'
 require 'rb-inotify/event'
+require 'rb-inotify/errors'
 
 # The root module of the library, which is laid out as so:
 #
@@ -10,8 +12,4 @@ require 'rb-inotify/event'
 # * {Watcher} -- A watcher for a single file or directory
 # * {Event} -- An filesystem event notification
 module INotify
-  # An array containing the version number of rb-inotify.
-  # The numbers in the array are the major, minor, and patch versions,
-  # respectively.
-  VERSION = [0, 8, 8]
 end

data/rb-inotify.gemspec

@@ -1,53 +1,28 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+require_relative 'lib/rb-inotify/version'
 
-Gem::Specification.new do |s|
-  s.name = %q{rb-inotify}
-  s.version = "0.8.8"
+Gem::Specification.new do |spec|
+  spec.name     = 'rb-inotify'
+  spec.version  = INotify::VERSION
+  spec.platform = Gem::Platform::RUBY
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Nathan Weizenbaum"]
-  s.date = %q{2011-09-27}
-  s.description = %q{A Ruby wrapper for Linux's inotify, using FFI}
-  s.email = %q{nex342@gmail.com}
-  s.extra_rdoc_files = [
-    "README.md"
-  ]
-  s.files = [
-    ".yardopts",
-    "MIT-LICENSE",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/rb-inotify.rb",
-    "lib/rb-inotify/event.rb",
-    "lib/rb-inotify/native.rb",
-    "lib/rb-inotify/native/flags.rb",
-    "lib/rb-inotify/notifier.rb",
-    "lib/rb-inotify/watcher.rb",
-    "rb-inotify.gemspec"
-  ]
-  s.homepage = %q{http://github.com/nex3/rb-inotify}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{A Ruby wrapper for Linux's inotify, using FFI}
+  spec.summary     = 'A Ruby wrapper for Linux inotify, using FFI'
+  spec.authors     = ['Natalie Weizenbaum', 'Samuel Williams']
+  spec.email       = ['nex342@gmail.com', 'samuel.williams@oriontransfer.co.nz']
+  spec.homepage    = 'https://github.com/guard/rb-inotify'
+  spec.licenses    = ['MIT']
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ffi>, [">= 0.5.0"])
-      s.add_development_dependency(%q<yard>, [">= 0.4.0"])
-    else
-      s.add_dependency(%q<ffi>, [">= 0.5.0"])
-      s.add_dependency(%q<yard>, [">= 0.4.0"])
-    end
-  else
-    s.add_dependency(%q<ffi>, [">= 0.5.0"])
-    s.add_dependency(%q<yard>, [">= 0.4.0"])
-  end
+  spec.files         = `git ls-files`.split($/)
+  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.required_ruby_version = '>= 2.2'
+  
+  spec.add_dependency "ffi", "~> 1.0"
+  
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "concurrent-ruby"
 end
-

data/spec/inotify_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe INotify do
+  describe "version" do
+    it "exists" do
+      expect(INotify::VERSION).to be_truthy
+    end
+  end
+end

data/spec/notifier_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'concurrent'
+
+describe INotify::Notifier do
+  describe "instance" do
+    around do |block|
+      Dir.mktmpdir do |dir|
+        @root = Pathname.new(dir)
+        @notifier = INotify::Notifier.new
+
+        begin
+          block.call
+        ensure
+          @notifier.close
+        end
+      end
+    end
+
+    let(:dir) do
+      @root.join("foo").tap(&:mkdir)
+    end
+
+    let(:another_dir) do
+      @root.join("bar").tap(&:mkdir)
+    end
+
+    it "stops" do
+      @notifier.stop
+    end
+
+    describe :process do
+      it "gets events" do
+        events = recording(dir, :create)
+        dir.join("test.txt").write("hello world")
+
+        @notifier.process
+
+        expect(events.size).to eq(1)
+        expect(events.first.name).to eq("test.txt")
+        expect(events.first.absolute_name).to eq(dir.join("test.txt").to_s)
+      end
+
+      it "gets simultaneous events" do
+        events = recording(dir, :create)
+
+        dir.join("one.txt").write("hello world")
+        dir.join("two.txt").write("hello world")
+
+        @notifier.process
+
+        expect(events.map(&:name)).to match_array(%w(one.txt two.txt))
+      end
+
+      it "separates events between watches" do
+        bar_events = nil
+
+        foo_events = recording(dir, :create)
+        bar_events = recording(another_dir, :create)
+
+        dir.join("test.txt").write("hello world")
+        another_dir.join("test_two.txt").write("hello world")
+
+        @notifier.process
+
+        expect(foo_events.size).to eq(1)
+        expect(foo_events.first.name).to eq("test.txt")
+        expect(foo_events.first.absolute_name).to eq(dir.join("test.txt").to_s)
+
+        expect(bar_events.size).to eq(1)
+        expect(bar_events.first.name).to eq("test_two.txt")
+        expect(bar_events.first.absolute_name).to eq(another_dir.join("test_two.txt").to_s)
+      end
+    end
+
+    describe :run do
+      it "processes repeatedly until stopped" do
+        barriers = Array.new(3) { Concurrent::Event.new }
+        barrier_queue = barriers.dup
+        events = recording(dir, :create) { barrier_queue.shift.set }
+
+        run_thread = Thread.new { @notifier.run }
+
+        dir.join("one.txt").write("hello world")
+        barriers.shift.wait(1) or raise "timeout"
+
+        expect(events.map(&:name)).to match_array(%w(one.txt))
+
+        dir.join("two.txt").write("hello world")
+        barriers.shift.wait(1) or raise "timeout"
+
+        expect(events.map(&:name)).to match_array(%w(one.txt two.txt))
+
+        @notifier.stop
+
+        dir.join("three.txt").write("hello world")
+        barriers.shift.wait(1)
+
+        dir.join("four.txt").write("hello world")
+        run_thread.join
+
+        expect(events.map(&:name)).to match_array(%w(one.txt two.txt))
+      end
+
+      it "can be stopped from within a callback" do
+        barriers = Array.new(3) { Concurrent::Event.new }
+        barrier_queue = barriers.dup
+        events = recording(dir, :create) { @notifier.stop }
+
+        run_thread = Thread.new { @notifier.run }
+        dir.join("one.txt").write("hello world")
+        run_thread.join
+      end
+    end
+
+    describe :fd do
+      it "returns an integer" do
+        expect(@notifier.fd).to be_an(Integer)
+      end
+    end
+
+    describe :to_io do
+      it "returns a ruby IO" do
+        expect(@notifier.to_io).to be_an(::IO)
+      end
+
+      it "matches the fd" do
+        expect(@notifier.to_io.fileno).to eq(@notifier.fd)
+      end
+
+      it "caches its result" do
+        expect(@notifier.to_io).to be(@notifier.to_io)
+      end
+
+      it "is selectable" do
+        events = recording(dir, :create)
+        expect(select([@notifier.to_io], nil, nil, 0.2)).to be_nil
+
+        dir.join("test.txt").write("hello world")
+        expect(select([@notifier.to_io], nil, nil, 0.2)).to eq([[@notifier.to_io], [], []])
+
+        @notifier.process
+        expect(select([@notifier.to_io], nil, nil, 0.2)).to be_nil
+      end
+    end
+
+    private
+
+    def recording(dir, *flags, callback: nil)
+      events = []
+      @notifier.watch(dir.to_s, *flags) do |event|
+        events << event
+        yield if block_given?
+      end
+
+      events
+    end
+  end
+
+  describe "mixed instances" do
+    it "doesn't tangle fds" do
+      notifiers = Array.new(30) { INotify::Notifier.new }
+      notifiers.each(&:to_io)
+
+      one = Array.new(10) { IO.pipe.last }
+      notifiers.each(&:close)
+
+      two = Array.new(10) { IO.pipe.last }
+
+      notifiers = nil
+      GC.start
+
+      _, writable, _ = select(nil, one, nil, 1)
+      expect(writable).to match_array(one)
+
+      _, writable, _ = select(nil, two, nil, 1)
+      expect(writable).to match_array(two)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+
+if ENV['COVERAGE'] || ENV['TRAVIS']
+	begin
+		require 'simplecov'
+		
+		SimpleCov.start do
+			add_filter "/spec/"
+		end
+		
+		if ENV['TRAVIS']
+			require 'coveralls'
+			Coveralls.wear!
+		end
+	rescue LoadError
+		warn "Could not load simplecov: #{$!}"
+	end
+end
+
+require "bundler/setup"
+require "rb-inotify"
+
+RSpec.configure do |config|
+	# Enable flags like --only-failures and --next-failure
+	config.example_status_persistence_file_path = ".rspec_status"
+
+	config.expect_with :rspec do |c|
+		c.syntax = :expect
+	end
+end

metadata

@@ -1,104 +1,137 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rb-inotify
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 8
-  - 8
-  version: 0.8.8
+version: !ruby/object:Gem::Version
+  version: 0.10.1
 platform: ruby
-authors: 
-- Nathan Weizenbaum
+authors:
+- Natalie Weizenbaum
+- Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-27 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2019-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 5
-        - 0
-        version: 0.5.0
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: yard
+      - !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
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 4
-        - 0
-        version: 0.4.0
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: A Ruby wrapper for Linux's inotify, using FFI
-email: nex342@gmail.com
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- nex342@gmail.com
+- samuel.williams@oriontransfer.co.nz
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.md
-files: 
-- .yardopts
-- MIT-LICENSE
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.md
 - README.md
 - Rakefile
-- VERSION
 - lib/rb-inotify.rb
+- lib/rb-inotify/errors.rb
 - lib/rb-inotify/event.rb
 - lib/rb-inotify/native.rb
 - lib/rb-inotify/native/flags.rb
 - lib/rb-inotify/notifier.rb
+- lib/rb-inotify/version.rb
 - lib/rb-inotify/watcher.rb
 - rb-inotify.gemspec
-has_rdoc: true
-homepage: http://github.com/nex3/rb-inotify
-licenses: []
-
+- spec/inotify_spec.rb
+- spec/notifier_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/guard/rb-inotify
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 3.0.4
 signing_key: 
-specification_version: 3
-summary: A Ruby wrapper for Linux's inotify, using FFI
-test_files: []
-
+specification_version: 4
+summary: A Ruby wrapper for Linux inotify, using FFI
+test_files:
+- spec/inotify_spec.rb
+- spec/notifier_spec.rb
+- spec/spec_helper.rb

data/MIT-LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Nathan Weizenbaum
-
-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/VERSION

@@ -1 +0,0 @@
-0.8.8