gameboard 3.1.0 → 3.2.0

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/.yardopts

@@ -1,4 +0,0 @@
---readme          README.md
---markup          markdown
---markup-provider maruku
---no-private

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/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/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/README.md

@@ -1,66 +0,0 @@
-# rb-inotify
-
-This is a simple wrapper over the [inotify](http://en.wikipedia.org/wiki/Inotify) Linux kernel subsystem
-for monitoring changes to files and directories.
-It uses the [FFI](http://wiki.github.com/ffi/ffi) gem to avoid having to compile a C extension.
-
-[API documentation is available on rdoc.info](http://rdoc.info/projects/nex3/rb-inotify).
-
-## Basic Usage
-
-The API is similar to the inotify C API, but with a more Rubyish feel.
-First, create a notifier:
-
-    notifier = INotify::Notifier.new
-
-Then, tell it to watch the paths you're interested in
-for the events you care about:
-
-    notifier.watch("path/to/foo.txt", :modify) {puts "foo.txt was modified!"}
-    notifier.watch("path/to/bar", :moved_to, :create) do |event|
-      puts "#{event.name} is now in path/to/bar!"
-    end
-
-Inotify can watch directories or individual files.
-It can pay attention to all sorts of events;
-for a full list, see [the inotify man page](http://www.tin.org/bin/man.cgi?section=7&topic=inotify).
-
-Finally, you get at the events themselves:
-
-    notifier.run
-
-This will loop infinitely, calling the appropriate callbacks when the files are changed.
-If you don't want infinite looping,
-you can also block until there are available events,
-process them all at once,
-and then continue on your merry way:
-
-    notifier.process
-
-## Advanced Usage
-
-Sometimes it's necessary to have finer control over the underlying IO operations
-than is provided by the simple callback API.
-The trick to this is that the \{INotify::Notifier#to_io Notifier#to_io} method
-returns a fully-functional IO object,
-with a file descriptor and everything.
-This means, for example, that it can be passed to `IO#select`:
-
-     # Wait 10 seconds for an event then give up
-     if IO.select([notifier.to_io], [], [], 10)
-       notifier.process
-     end
-
-It can even be used with EventMachine:
-
-     require 'eventmachine'
-
-     EM.run do
-       EM.watch notifier.to_io do
-         notifier.process
-       end
-     end
-
-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.

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/Rakefile

@@ -1,54 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-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')
-
-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
-
-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
-end

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/VERSION

@@ -1 +0,0 @@
-0.9.7

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/lib/rb-inotify.rb

@@ -1,18 +0,0 @@
-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:
-#
-# * {Notifier} -- The main class, where the notifications are set up
-# * {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, 9, 7]
-end

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/lib/rb-inotify/errors.rb

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

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/lib/rb-inotify/event.rb

@@ -1,146 +0,0 @@
-module INotify
-  # An event caused by a change on the filesystem.
-  # Each {Watcher} can fire many events,
-  # which are passed to that watcher's callback.
-  class Event
-    # A list of other events that are related to this one.
-    # Currently, this is only used for files that are moved within the same directory:
-    # the `:moved_from` and the `:moved_to` events will be related.
-    #
-    # @return [Array<Event>]
-    attr_reader :related
-
-    # The name of the file that the event occurred on.
-    # This is only set for events that occur on files in directories;
-    # otherwise, it's `""`.
-    # Similarly, if the event is being fired for the directory itself
-    # the name will be `""`
-    #
-    # This pathname is relative to the enclosing directory.
-    # For the absolute pathname, use \{#absolute\_name}.
-    # Note that when the `:recursive` flag is passed to {Notifier#watch},
-    # events in nested subdirectories will still have a `#name` field
-    # relative to their immediately enclosing directory.
-    # For example, an event on the file `"foo/bar/baz"`
-    # will have name `"baz"`.
-    #
-    # @return [String]
-    attr_reader :name
-
-    # The {Notifier} that fired this event.
-    #
-    # @return [Notifier]
-    attr_reader :notifier
-
-    # An integer specifying that this event is related to some other event,
-    # which will have the same cookie.
-    #
-    # Currently, this is only used for files that are moved within the same directory.
-    # Both the `:moved_from` and the `:moved_to` events will have the same cookie.
-    #
-    # @private
-    # @return [Fixnum]
-    attr_reader :cookie
-
-    # The {Watcher#id id} of the {Watcher} that fired this event.
-    #
-    # @private
-    # @return [Fixnum]
-    attr_reader :watcher_id
-
-    # Returns the {Watcher} that fired this event.
-    #
-    # @return [Watcher]
-    def watcher
-      @watcher ||= @notifier.watchers[@watcher_id]
-    end
-
-    # The absolute path of the file that the event occurred on.
-    #
-    # This is actually only as absolute as the path passed to the {Watcher}
-    # that created this event.
-    # However, it is relative to the working directory,
-    # assuming that hasn't changed since the watcher started.
-    #
-    # @return [String]
-    def absolute_name
-      return watcher.path if name.empty?
-      return File.join(watcher.path, name)
-    end
-
-    # Returns the flags that describe this event.
-    # This is generally similar to the input to {Notifier#watch},
-    # except that it won't contain options flags nor `:all_events`,
-    # and it may contain one or more of the following flags:
-    #
-    # `:unmount`
-    # : The filesystem containing the watched file or directory was unmounted.
-    #
-    # `:ignored`
-    # : The \{#watcher watcher} was closed, or the watched file or directory was deleted.
-    #
-    # `:isdir`
-    # : The subject of this event is a directory.
-    #
-    # @return [Array<Symbol>]
-    def flags
-      @flags ||= Native::Flags.from_mask(@native[:mask])
-    end
-
-    # Constructs an {Event} object from a string of binary data,
-    # and destructively modifies the string to get rid of the initial segment
-    # used to construct the Event.
-    #
-    # @private
-    # @param data [String] The string to be modified
-    # @param notifier [Notifier] The {Notifier} that fired the event
-    # @return [Event, nil] The event, or `nil` if the string is empty
-    def self.consume(data, notifier)
-      return nil if data.empty?
-      ev = new(data, notifier)
-      data.replace data[ev.size..-1]
-      ev
-    end
-
-    # Creates an event from a string of binary data.
-    # Differs from {Event.consume} in that it doesn't modify the string.
-    #
-    # @private
-    # @param data [String] The data string
-    # @param notifier [Notifier] The {Notifier} that fired the event
-    def initialize(data, notifier)
-      ptr = FFI::MemoryPointer.from_string(data)
-      @native = Native::Event.new(ptr)
-      @related = []
-      @cookie = @native[:cookie]
-      @name = fix_encoding(data[@native.size, @native[:len]].gsub(/\0+$/, ''))
-      @notifier = notifier
-      @watcher_id = @native[:wd]
-
-      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,
-    # passing in the event itself.
-    #
-    # @private
-    def callback!
-      watcher.callback!(self)
-    end
-
-    # Returns the size of this event object in bytes,
-    # including the \{#name} string.
-    #
-    # @return [Fixnum]
-    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/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/lib/rb-inotify/native.rb

@@ -1,31 +0,0 @@
-require 'ffi'
-
-module INotify
-  # This module contains the low-level foreign-function interface code
-  # for dealing with the inotify C APIs.
-  # It's an implementation detail, and not meant for users to deal with.
-  #
-  # @private
-  module Native
-    extend FFI::Library
-    ffi_lib FFI::Library::LIBC
-
-    # The C struct describing an inotify event.
-    #
-    # @private
-    class Event < FFI::Struct
-      layout(
-        :wd, :int,
-        :mask, :uint32,
-        :cookie, :uint32,
-        :len, :uint32)
-    end
-
-    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
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/lib/rb-inotify/native/flags.rb

@@ -1,89 +0,0 @@
-module INotify
-  module Native
-    # A module containing all the inotify flags
-    # to be passed to {Notifier#watch}.
-    #
-    # @private
-    module Flags
-      # File was accessed.
-      IN_ACCESS = 0x00000001
-      # Metadata changed.
-      IN_ATTRIB = 0x00000004
-      # Writtable file was closed.
-      IN_CLOSE_WRITE = 0x00000008
-      # File was modified.
-      IN_MODIFY = 0x00000002
-      # Unwrittable file closed.
-      IN_CLOSE_NOWRITE = 0x00000010
-      # File was opened.
-      IN_OPEN = 0x00000020
-      # File was moved from X.
-      IN_MOVED_FROM = 0x00000040
-      # File was moved to Y.
-      IN_MOVED_TO = 0x00000080
-      # Subfile was created.
-      IN_CREATE = 0x00000100
-      # Subfile was deleted.
-      IN_DELETE = 0x00000200
-      # Self was deleted.
-      IN_DELETE_SELF = 0x00000400
-      # Self was moved.
-      IN_MOVE_SELF = 0x00000800
-
-      ## Helper events.
-
-      # Close.
-      IN_CLOSE = (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
-      # Moves.
-      IN_MOVE = (IN_MOVED_FROM | IN_MOVED_TO)
-      # All events which a program can wait on.
-      IN_ALL_EVENTS = (IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE |
-        IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM | IN_MOVED_TO | IN_CREATE |
-        IN_DELETE | IN_DELETE_SELF | IN_MOVE_SELF)
-
-
-      ## Special flags.
-
-      # Only watch the path if it is a directory.
-      IN_ONLYDIR = 0x01000000
-      # Do not follow a sym link.
-      IN_DONT_FOLLOW = 0x02000000
-      # Add to the mask of an already existing watch.
-      IN_MASK_ADD = 0x20000000
-      # Only send event once.
-      IN_ONESHOT = 0x80000000
-
-
-      ## Events sent by the kernel.
-
-      # Backing fs was unmounted.
-      IN_UNMOUNT = 0x00002000
-      # Event queued overflowed.
-      IN_Q_OVERFLOW = 0x00004000
-      # File was ignored.
-      IN_IGNORED = 0x00008000
-      # Event occurred against dir.
-      IN_ISDIR = 0x40000000
-
-      # Converts a list of flags to the bitmask that the C API expects.
-      #
-      # @param flags [Array<Symbol>]
-      # @return [Fixnum]
-      def self.to_mask(flags)
-        flags.map {|flag| const_get("IN_#{flag.to_s.upcase}")}.
-          inject(0) {|mask, flag| mask | flag}
-      end
-
-      # Converts a bitmask from the C API into a list of flags.
-      #
-      # @param mask [Fixnum]
-      # @return [Array<Symbol>]
-      def self.from_mask(mask)
-        constants.map {|c| c.to_s}.select do |c|
-          next false unless c =~ /^IN_/
-          const_get(c) & mask != 0
-        end.map {|c| c.sub("IN_", "").downcase.to_sym} - [:all_events]
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rb-inotify-0.9.7/lib/rb-inotify/notifier.rb

@@ -1,328 +0,0 @@
-module INotify
-  # Notifier wraps a single instance of inotify.
-  # It's possible to have more than one instance,
-  # but usually unnecessary.
-  #
-  # @example
-  #   # Create the notifier
-  #   notifier = INotify::Notifier.new
-  #
-  #   # Run this callback whenever the file path/to/foo.txt is read
-  #   notifier.watch("path/to/foo.txt", :access) do
-  #     puts "Foo.txt was accessed!"
-  #   end
-  #
-  #   # Watch for any file in the directory being deleted
-  #   # or moved out of the directory.
-  #   notifier.watch("path/to/directory", :delete, :moved_from) do |event|
-  #     # The #name field of the event object contains the name of the affected file
-  #     puts "#{event.name} is no longer in the directory!"
-  #   end
-  #
-  #   # Nothing happens until you run the notifier!
-  #   notifier.run
-  class Notifier
-    # A list of directories that should never be recursively watched.
-    #
-    # * Files in `/dev/fd` sometimes register as directories, but are not enumerable.
-    RECURSIVE_BLACKLIST = %w[/dev/fd]
-
-    # A hash from {Watcher} ids to the instances themselves.
-    #
-    # @private
-    # @return [{Fixnum => Watcher}]
-    attr_reader :watchers
-
-    # The underlying file descriptor for this notifier.
-    # This is a valid OS file descriptor, and can be used as such
-    # (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/
-    end
-
-    # Creates a new {Notifier}.
-    #
-    # @return [Notifier]
-    # @raise [SystemCallError] if inotify failed to initialize for some reason
-    def initialize
-      @fd = Native.inotify_init
-      @watchers = {}
-      return unless @fd < 0
-
-      raise SystemCallError.new(
-        "Failed to initialize inotify" +
-        case FFI.errno
-        when Errno::EMFILE::Errno; ": the user limit on the total number of inotify instances has been reached."
-        when Errno::ENFILE::Errno; ": the system limit on the total number of file descriptors has been reached."
-        when Errno::ENOMEM::Errno; ": insufficient kernel memory is available."
-        else; ""
-        end,
-        FFI.errno)
-    end
-
-    # Returns a Ruby IO object wrapping the underlying file descriptor.
-    # Since this file descriptor is fully functional (except under JRuby),
-    # this IO object can be used in any way a Ruby-created IO object can.
-    # This includes passing it to functions like `#select`.
-    #
-    # Note that this always returns the same IO object.
-    # Creating lots of IO objects for the same file descriptor
-    # can cause some odd problems.
-    #
-    # **This is not supported under JRuby**.
-    # JRuby currently doesn't use native file descriptors for the IO object,
-    # so we can't use this file descriptor as a stand-in.
-    #
-    # @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)
-    end
-
-    # Watches a file or directory for changes,
-    # calling the callback when there are.
-    # This is only activated once \{#process} or \{#run} is called.
-    #
-    # **Note that by default, this does not recursively watch subdirectories
-    # of the watched directory**.
-    # To do so, use the `:recursive` flag.
-    #
-    # ## Flags
-    #
-    # `:access`
-    # : A file is accessed (that is, read).
-    #
-    # `:attrib`
-    # : A file's metadata is changed (e.g. permissions, timestamps, etc).
-    #
-    # `:close_write`
-    # : A file that was opened for writing is closed.
-    #
-    # `:close_nowrite`
-    # : A file that was not opened for writing is closed.
-    #
-    # `:modify`
-    # : A file is modified.
-    #
-    # `:open`
-    # : A file is opened.
-    #
-    # ### Directory-Specific Flags
-    #
-    # These flags only apply when a directory is being watched.
-    #
-    # `:moved_from`
-    # : A file is moved out of the watched directory.
-    #
-    # `:moved_to`
-    # : A file is moved into the watched directory.
-    #
-    # `:create`
-    # : A file is created in the watched directory.
-    #
-    # `:delete`
-    # : A file is deleted in the watched directory.
-    #
-    # `:delete_self`
-    # : The watched file or directory itself is deleted.
-    #
-    # `:move_self`
-    # : The watched file or directory itself is moved.
-    #
-    # ### Helper Flags
-    #
-    # These flags are just combinations of the flags above.
-    #
-    # `:close`
-    # : Either `:close_write` or `:close_nowrite` is activated.
-    #
-    # `:move`
-    # : Either `:moved_from` or `:moved_to` is activated.
-    #
-    # `:all_events`
-    # : Any event above is activated.
-    #
-    # ### Options Flags
-    #
-    # These flags don't actually specify events.
-    # Instead, they specify options for the watcher.
-    #
-    # `:onlydir`
-    # : Only watch the path if it's a directory.
-    #
-    # `:dont_follow`
-    # : Don't follow symlinks.
-    #
-    # `:mask_add`
-    # : Add these flags to the pre-existing flags for this path.
-    #
-    # `:oneshot`
-    # : Only send the event once, then shut down the watcher.
-    #
-    # `:recursive`
-    # : Recursively watch any subdirectories that are created.
-    #   Note that this is a feature of rb-inotify,
-    #   rather than of inotify itself, which can only watch one level of a directory.
-    #   This means that the {Event#name} field
-    #   will contain only the basename of the modified file.
-    #   When using `:recursive`, {Event#absolute_name} should always be used.
-    #
-    # @param path [String] The path to the file or directory
-    # @param flags [Array<Symbol>] Which events to watch for
-    # @yield [event] A block that will be called
-    #   whenever one of the specified events occur
-    # @yieldparam event [Event] The Event object containing information
-    #   about the event that occured
-    # @return [Watcher] A Watcher set up to watch this path for these events
-    # @raise [SystemCallError] if the file or directory can't be watched,
-    #   e.g. if the file isn't found, read access is denied,
-    #   or the flags don't contain any events
-    def watch(path, *flags, &callback)
-      return Watcher.new(self, path, *flags, &callback) unless flags.include?(:recursive)
-
-      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)
-      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?
-        next if (rec_flags & event.flags).empty? || !event.flags.include?(:isdir)
-        begin
-          watch(event.absolute_name, *flags, &callback)
-        rescue Errno::ENOENT
-          # If the file has been deleted since the glob was run, we don't want to error out.
-        end
-      end
-    end
-
-    # Starts the notifier watching for filesystem events.
-    # Blocks until \{#stop} is called.
-    #
-    # @see #process
-    def run
-      @stop = false
-      process until @stop
-    end
-
-    # Stop watching for filesystem events.
-    # That is, if we're in a \{#run} loop,
-    # exit out as soon as we finish handling the events.
-    def stop
-      @stop = true
-    end
-
-    # Blocks until there are one or more filesystem events
-    # that this notifier has watchers registered for.
-    # Once there are events, the appropriate callbacks are called
-    # and this function returns.
-    #
-    # @see #run
-    def process
-      read_events.each {|event| event.callback!}
-    end
-
-    # Close the notifier.
-    #
-    # @raise [SystemCallError] if closing the underlying file descriptor fails.
-    def close
-      stop
-      if Native.close(@fd) == 0
-        @watchers.clear
-        return
-      end
-
-      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)
-    end
-
-    # 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
-      tries = 1
-
-      begin
-        data = readpartial(size)
-      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
-        size *= 2
-        tries += 1
-        retry
-      end
-      return [] if data.nil?
-
-      events = []
-      cookies = {}
-      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.
-      begin
-        return to_io.readpartial(size) if self.class.supports_ruby_io?
-      rescue Errno::EBADF
-        # If the IO has already been closed, reading from it will cause
-        # Errno::EBADF.
-        return nil
-      end
-
-      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)
-    end
-  end
-end