joshbuddy-guard 0.10.0

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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,53 @@
+# 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

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

data/lib/vendor/windows/README.md

@@ -0,0 +1,34 @@
+# rb-fchange
+
+Code is working. But there is still a lot of work.
+This is a simple wrapper over the Windows Kernel functions for monitoring the specified directory or subtree.
+Tested on:
+
+ - jruby 1.6.1 (ruby-1.8.7-p330) (2011-04-12 85838f6)
+ - ruby 1.8.7 (2011-02-18 patchlevel 334) [i386-ingw32]
+ - ruby 1.9.2p180 (2011-02-18) [i386-mingw32]
+
+Example
+
+```ruby
+  require 'rb-fchange'
+  
+  notifier = FChange::Notifier.new
+  notifier.watch("test", :all_events, :recursive) do |event|
+    p Time.now.utc
+  end
+  
+  Signal.trap('INT') do
+    p "Bye bye...",
+    notifier.stop
+    abort("\n")
+  end
+  
+  notifier.run
+```
+
+## TODO
+
+ - add latency setting with 0.5 default
+ - rework interface (should more look like rb-fsevent)
+ - add none-ANSI path support

data/lib/vendor/windows/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace(:spec) do
+  desc "Run all specs on multiple ruby versions (requires pik)"
+  task(:portability) do
+    %w[187 192 161].each do |version|
+       system("echo -----------#{version}------------")
+       system("pik use #{version}")
+       system("bundle install")
+       system("rake spec")
+    end
+  end
+end

data/lib/vendor/windows/lib/rb-fchange.rb

@@ -0,0 +1,14 @@
+require "rb-fchange/native"
+require "rb-fchange/native/flags"
+require "rb-fchange/notifier"
+require "rb-fchange/watcher"
+require "rb-fchange/event"
+
+# 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 FChange
+
+end

data/lib/vendor/windows/lib/rb-fchange/event.rb

@@ -0,0 +1,29 @@
+module FChange
+  # 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
+    # The {Watcher} that fired this event.
+    #
+    # @return [Watcher]
+    attr_reader :watcher
+    
+    # Creates an event from a string of binary data.
+    # Differs from {Event.consume} in that it doesn't modify the string.
+    #
+    # @private
+    # @param watcher [Watcher] The {Watcher} that fired the event
+    def initialize(watcher)
+      @watcher = watcher
+    end
+
+    # Calls the callback of the watcher that fired this event,
+    # passing in the event itself.
+    #
+    # @private
+    def callback!
+      @watcher.callback!(self)
+    end
+
+  end
+end

data/lib/vendor/windows/lib/rb-fchange/native.rb

@@ -0,0 +1,45 @@
+require 'ffi'
+
+module FChange
+  # This module contains the low-level foreign-function.
+  # It's an implementation detail, and not meant for users to deal with.
+  #
+  # @private
+  module Native
+    extend FFI::Library
+    ffi_lib 'kernel32'
+    ffi_convention :stdcall
+
+    # HANDLE FindFirstChangeNotification(
+    #  LPCTSTR lpPathName,    // directory name
+    #  BOOL bWatchSubtree,    // monitoring option
+    #  DWORD dwNotifyFilter   // filter conditions
+    #);
+    attach_function :FindFirstChangeNotificationW, [:pointer, :int, :long], :long
+
+    # HANDLE FindFirstChangeNotification(
+    #  LPCTSTR lpPathName,    // directory name
+    #  BOOL bWatchSubtree,    // monitoring option
+    #  DWORD dwNotifyFilter   // filter conditions
+    #);
+    attach_function :FindFirstChangeNotificationA, [:pointer, :int, :long], :long
+
+    # BOOL FindNextChangeNotification(
+    #  HANDLE hChangeHandle   // handle to change notification
+    # );
+    attach_function :FindNextChangeNotification, [:long], :int
+
+    # DAORD WaitForMultipleObjects(
+    #   DWORD nCount,             // number of handles in array
+    #   CONST HANDLE *lpHandles,  // object-handle array
+    #   BOOL bWaitAll,            // wait option
+    #   DWORD dwMilliseconds      // time-out interval
+    # );
+    attach_function :WaitForMultipleObjects, [:long, :pointer, :int, :long], :long
+
+    # BOOL FindCloseChangeNotification(
+    #   HANDLE hChangeHandle
+    # );
+    attach_function :FindCloseChangeNotification, [:long], :int
+  end
+end

data/lib/vendor/windows/lib/rb-fchange/native/flags.rb

@@ -0,0 +1,78 @@
+module FChange
+  module Native
+    # A module containing all the flags to be passed to {Notifier#watch}.
+    # @see http://msdn.microsoft.com/en-us/library/aa364417(v=VS.85).aspx 
+    # 
+    # @private
+    module Flags
+
+      # Any file name change in the watched directory or subtree causes a change
+      # notification wait operation to return. Changes include renaming, 
+      # creating, or deleting a file name.
+      FILE_NOTIFY_CHANGE_FILE_NAME   = 0x00000001
+
+      # Any directory-name change in the watched directory or subtree causes a 
+      # change notification wait operation to return. Changes include creating 
+      # or deleting a directory.
+      FILE_NOTIFY_CHANGE_DIR_NAME    = 0x00000002
+
+      # Any attribute change in the watched directory or subtree causes a change
+      # notification wait operation to return.
+      FILE_NOTIFY_CHANGE_ATTRIBUTES  = 0x00000004
+
+      # Any file-size change in the watched directory or subtree causes a change
+      # notification wait operation to return. The operating system detects a 
+      # change in file size only when the file is written to the disk. 
+      # For operating systems that use extensive caching, detection occurs only 
+      # when the cache is sufficiently flushed.
+      FILE_NOTIFY_CHANGE_SIZE        = 0x00000008
+
+      # Any change to the last write-time of files in the watched directory or 
+      # subtree causes a change notification wait operation to return.
+      # The operating system detects a change to the last write-time only when 
+      # the file is written to the disk. For operating systems that use 
+      # extensive caching, detection occurs only when the cache is sufficiently 
+      # flushed
+      FILE_NOTIFY_CHANGE_LAST_WRITE  = 0x00000010
+
+      # Any change to the last access time of files in the watched directory or 
+      # subtree causes a change notification wait operation to return.
+      FILE_NOTIFY_CHANGE_LAST_ACCESS = 0x00000020
+
+      # Any change to the creation time of files in the watched directory or 
+      # subtree causes a change notification wait operation to return.
+      FILE_NOTIFY_CHANGE_CREATION    = 0x00000040
+
+      # Any security-descriptor change in the watched directory or subtree 
+      # causes a change notification wait operation to return.
+      FILE_NOTIFY_CHANGE_SECURITY    = 0x00000100
+
+      FILE_NOTIFY_CHANGE_ALL_EVENTS = (
+        FILE_NOTIFY_CHANGE_DIR_NAME |
+        FILE_NOTIFY_CHANGE_FILE_NAME |
+        FILE_NOTIFY_CHANGE_LAST_WRITE
+      )
+
+      # 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("FILE_NOTIFY_CHANGE_#{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 =~ /^FILE_NOTIFY_CHANGE_/
+          const_get(c) & mask != 0
+        end.map {|c| c.sub("FILE_NOTIFY_CHANGE_", "").downcase.to_sym} - [:all_events]
+      end
+
+    end
+  end
+end

data/lib/vendor/windows/lib/rb-fchange/notifier.rb

@@ -0,0 +1,149 @@
+module FChange
+  # Notifier wraps a single instance of FChange.
+  # It's possible to have more than one instance,
+  # but usually unnecessary.
+  #
+  # @example
+  #   # Create the notifier
+  #   notifier = FChange::Notifier.new
+  #
+  #   # Run this callback whenever the file path/to/foo.txt is read
+  #   notifier.watch("path/to/foo/", :all_events) do
+  #     puts "foo was accessed!"
+  #   end
+  #
+  #   # Nothing happens until you run the notifier!
+  #   notifier.run
+  class Notifier
+
+    #
+    INFINITE = 0xFFFFFFFF
+
+    #
+    WAIT_OBJECT_0 = 0x00000000
+
+    # A hash from {Watcher} ids to the instances themselves.
+    #
+    # @private
+    # @return [{Fixnum => Watcher}]
+    attr_reader :watchers
+    
+    attr_reader :dwChangeHandles
+    attr_reader :lp_dwChangeHandles
+
+    # Creates a new {Notifier}.
+    #
+    # @return [Notifier] 
+    def initialize
+      @watchers = {}
+      @dwChangeHandles = []
+      @lp_dwChangeHandles = 0
+    end
+
+    # Adds a new {Watcher} to the queue.
+    def add_watcher(watcher)
+
+      @watchers[watcher.id] = watcher
+
+      @dwChangeHandles.push watcher.id
+
+      # Pack event handles into newly created storage area 
+      # to be used for Win32 call
+      @lp_dwChangeHandles = dwChangeHandles.pack("L" * dwChangeHandles.count)
+
+    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.
+    #
+    # `:recursive`
+    # : Recursively watch any subdirectories that are created.
+    #
+    # @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)
+      recursive = flags.include?(:recursive)
+      #:latency = 0.5
+      flags = flags - [:recursive]
+      if flags.empty?
+        @flags = [:all_events]
+      else
+        @flags = flags.freeze
+      end
+      Watcher.new(self, path, recursive, *@flags, &callback)
+    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
+
+    # Blocks until there are one or more filesystem events
+    # that this notifier has watchers registered for.
+    # Once there are events, returns their {Event} objects.
+    #
+    # @private
+    def read_events
+
+      # can return WAIT_TIMEOUT  = 0x00000102
+      dwWaitStatus = Native.WaitForMultipleObjects(@dwChangeHandles.count, 
+        @lp_dwChangeHandles, 0, 500)
+
+      events = []
+
+      # this call blocks all threads completely.
+      @dwChangeHandles.each_index do |index|
+        if dwWaitStatus == WAIT_OBJECT_0 + index
+
+          ev = Event.new(@watchers[@dwChangeHandles[index]])
+          events << ev
+        
+          r = Native.FindNextChangeNotification(@dwChangeHandles[index]) 
+          if r == 0 
+              raise SystemCallError.new("Failed to watch", r) 
+          end
+        end
+      end
+      events
+    end
+
+    def close
+      
+    end
+
+  end
+end