guard 1.0.3 → 1.1.0.alpha

data/lib/vendor/linux/lib/rb-inotify/notifier.rb

@@ -1,308 +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.glob(File.join(path, '*'), File::FNM_DOTMATCH).each do |d|
-        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
-
-      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
-      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)
-    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.
-    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
-
-      events = []
-      cookies = {}
-      while ev = Event.consume(data, self)
-        events << ev
-        next if ev.cookie == 0
-        cookies[ev.cookie] ||= []
-        cookies[ev.cookie] << ev
-      end
-      cookies.each {|c, evs| evs.each {|ev| ev.related.replace(evs - [ev]).freeze}}
-      events
-    end
-
-    # 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)
-    end
-  end
-end

data/lib/vendor/linux/lib/rb-inotify/watcher.rb

@@ -1,83 +0,0 @@
-module INotify
-  # Watchers monitor a single path for changes,
-  # specified by {INotify::Notifier#watch event flags}.
-  # A watcher is usually created via \{Notifier#watch}.
-  #
-  # One {Notifier} may have many {Watcher}s.
-  # The Notifier actually takes care of the checking for events,
-  # via \{Notifier#run #run} or \{Notifier#process #process}.
-  # The main purpose of having Watcher objects
-  # is to be able to disable them using \{#close}.
-  class Watcher
-    # The {Notifier} that this Watcher belongs to.
-    #
-    # @return [Notifier]
-    attr_reader :notifier
-
-    # The path that this Watcher is watching.
-    #
-    # @return [String]
-    attr_reader :path
-
-    # The {INotify::Notifier#watch flags}
-    # specifying the events that this Watcher is watching for,
-    # and potentially some options as well.
-    #
-    # @return [Array<Symbol>]
-    attr_reader :flags
-
-    # The id for this Watcher.
-    # Used to retrieve this Watcher from {Notifier#watchers}.
-    #
-    # @private
-    # @return [Fixnum]
-    attr_reader :id
-
-    # Calls this Watcher's callback with the given {Event}.
-    #
-    # @private
-    # @param event [Event]
-    def callback!(event)
-      @callback[event]
-    end
-
-    # Disables this Watcher, so that it doesn't fire any more events.
-    #
-    # @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)
-    end
-
-    # Creates a new {Watcher}.
-    #
-    # @private
-    # @see Notifier#watch
-    def initialize(notifier, path, *flags, &callback)
-      @notifier = notifier
-      @callback = callback || proc {}
-      @path = path
-      @flags = flags.freeze
-      @id = Native.inotify_add_watch(@notifier.fd, path.dup,
-        Native::Flags.to_mask(flags))
-
-      unless @id < 0
-        @notifier.watchers[@id] = self
-        return
-      end
-
-      raise SystemCallError.new(
-        "Failed to watch #{path.inspect}" +
-        case FFI.errno
-        when Errno::EACCES::Errno; ": read access to the given file is not permitted."
-        when Errno::EBADF::Errno; ": the given file descriptor is not valid."
-        when Errno::EFAULT::Errno; ": path points outside of the process's accessible address space."
-        when Errno::EINVAL::Errno; ": the given event mask contains no legal events; or fd is not an inotify file descriptor."
-        when Errno::ENOMEM::Errno; ": insufficient kernel memory was available."
-        when Errno::ENOSPC::Errno; ": The user limit on the total number of inotify watches was reached or the kernel failed to allocate a needed resource."
-        else; ""
-        end,
-        FFI.errno)
-    end
-  end
-end

data/lib/vendor/linux/rb-inotify.gemspec

@@ -1,53 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{rb-inotify}
-  s.version = "0.8.8"
-
-  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}
-
-  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
-end
-

data/lib/vendor/windows/Gemfile

@@ -1,4 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in rb-fchange.gemspec
-gemspec