wires-inotify 0.0.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2423071eef69cd0ebd58674bd6efd9439888041a
-  data.tar.gz: 29d3e0cfdedfa6f02fa6c9117128401db82cbce6
+  metadata.gz: bb199f81f59733bfb394ffc5e661cf0a5a10644a
+  data.tar.gz: 4fc657e5e03df97fb2aa6cf195114dede637dd71
 SHA512:
-  metadata.gz: b5377b54fb99edaf005c64b3b2faa99ca5080b882210d4912777169c6ec9f9f77c448e216d4b1313f54b91e8ee121337f5587493169710186aa390df1204f044
-  data.tar.gz: 1700aeaddb5d2b351b1313ab573843d47aa6862114c948519d2e4bfab5687f132ff78299061230552d2423c5ca0e434e5cbb20fae1d59641e531e751744c1b1f
+  metadata.gz: e823a8f3d3525a9dcfd02b78a4deaa295d755aab567d85ec0b94524e294d281ecee8cb4755dec067daedf2c54a11dd530a40fb9d6c7570b2ded4c5b4f03626bb
+  data.tar.gz: e4ef111babbf2e1642de9dc73901add6ba0659dacb1e89ef33446e27f400b231e93faef9fb037b37f69e583eebe259b9d4889a6979707aa701c77e27945502f8

data/lib/wires/inotify.rb

@@ -0,0 +1,166 @@
+require 'wires'
+require 'rb-inotify'
+
+def inotify_watch(path, *flags)
+  Wires::NotifyHub.watch(path, *flags)
+end
+
+def inotify_on(flags, channels='*', &codeblock)
+  flags    = [flags]    unless flags.is_a?    Array
+  channels = [channels] unless channels.is_a? Array
+  for channel in channels
+    Wires::NotifyHub.watch(channel, *flags)
+    events = flags.map!{|x| ("notify_"+x.to_s).to_sym}
+                  .map!{|x| x==:notify_all_events ? :notify : x }
+    Wires::Channel.new(channel).register(events, codeblock)
+  end
+nil end
+
+module Wires
+  
+  class NotifyEvent             < Event; end
+  
+  class NotifyAccessEvent       < NotifyEvent; end
+  class NotifyAttribEvent       < NotifyEvent; end
+  class NotifyModifyEvent       < NotifyEvent; end
+  class NotifyOpenEvent         < NotifyEvent; end
+  class NotifyCreateEvent       < NotifyEvent; end
+  class NotifyDeleteEvent       < NotifyEvent; end
+  class NotifyDeleteSelfEvent   < NotifyEvent; end
+  class NotifyMoveSelfEvent     < NotifyEvent; end
+  class NotifyIgnoredEvent      < NotifyEvent; end
+  
+  class NotifyCloseEvent        < NotifyEvent; end
+  class NotifyCloseWriteEvent   < NotifyCloseEvent; end
+  class NotifyCloseNowriteEvent < NotifyCloseEvent; end
+  
+  class NotifyMoveEvent         < NotifyEvent; end
+  class NotifyMovedFromEvent    < NotifyMoveEvent; end
+  class NotifyMovedToEvent      < NotifyMoveEvent; end
+  
+  class NotifyHub
+    
+    class << self
+      
+      attr_accessor :notifier
+      attr_reader   :state
+      def alive?; @state==:alive end
+      def dead?;  @state==:dead  end
+      
+      def class_init
+        
+        # @@events_init = EventRegistry.list.select{ |x| (x < NotifyEvent) }
+        @@events = Hash.new
+        EventRegistry.list.select{ |x| (x < NotifyEvent) }.each do |cls|
+          @@events[cls.codestring.gsub(/^notify_/, "").to_sym] = cls
+        end
+        
+        @state = :dead
+        @notifier = INotify::Notifier.new
+        
+        Hub.after_run(retain:true) do
+          @state = :alive
+          @thread = Thread.new { while alive?; thread_iter; Thread.pass; end }
+        end
+        
+        Hub.before_kill(retain:true) do
+          @state = :dead
+          @thread.kill
+          @thread = nil
+        end
+      end
+      
+      def watch(path, *flags, &block)
+        flags << :all_events if (flags & @@events.keys).empty?
+        inject_a_watcher(@notifier.watch(path, *flags, &block))
+      end
+      
+      def list
+        @notifier.watchers.values
+                 .map { |w| inject_a_watcher(w)} # Inject new methods into obj
+                 .reject { |w| w.closed? } # Exclude closed watchers from list
+      end
+      
+      def matching(path=/.*/, *flags)
+        list.select { |w| (path.is_a?(Regexp)) ? 
+                            (path=~w.path) : 
+                            (path.to_s==w.path) }
+            .reject { |w| flags.detect{ |f| not flag_match(f, w.flags) } }
+      end
+      
+      # Close all watchers and returns number of watchers closed
+      def close_all
+        s = list.size
+        list.each { |w| w.close }
+        s>0 ? s : nil
+      end
+      
+      # Close watchers matching args and returns number of watchers closed
+      def close_matching(*args) # :args: path=/.*/, *flags
+        matches = matching(*args)
+        matches.each { |w| w.close }
+        (s=matches.size)>0 ? s : nil
+      end
+      
+      threadlock (public_methods-superclass.public_methods)
+      
+      
+    private
+      
+      # Determine if flag is implied (or explied) by flags array
+      def flag_match(testflag, flags)
+        return true if flags.include? :all_events
+        
+        !!flags.detect{ |f| testflag==f or
+                            (@@events[testflag] and 
+                             @@events[f] and 
+                             @@events[testflag]<=@@events[f]) }
+      end
+      
+      # Open metaclass of w to add close state tracking and return obj
+      def inject_a_watcher(watcher)
+        return watcher if watcher.public_methods.include? :closed?
+        
+        watcher.instance_variable_set(:@closed, false)
+        class << watcher
+          alias :_old_close :close
+          def close(*args)
+            self.instance_variable_set(:@closed, true)
+            begin; _old_close(*args)
+            rescue SystemCallError; end # If error, assume already closed
+          end
+          def closed?; self.instance_variable_get(:@closed); end
+        end
+        
+        watcher
+      end
+      
+      # Called repeatedly in inotify event processing thread
+      def thread_iter
+        @notifier.read_events.each { |e| process_event(e); e.callback! }
+      end
+      
+      # Fire a wires event for inotify event e
+      def process_event(e)
+        return if dead?
+        
+        if (common_flags = (e.flags & @@events.keys)).empty?
+          raise NotImplementedError, \
+            "No Wires::NotifyEvent for flags #{e.flags}"
+        end
+        
+        cls = Event.from_codestring("notify_"+common_flags.first.to_s)
+        
+        Channel.new(e.watcher.path)
+               .fire(cls.new(*e.flags,
+                            name:          e.name,
+                            absolute_name: e.absolute_name,
+                            watchpath:     e.watcher.path))
+      end
+      
+    end
+    
+    class_init
+  end
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires-inotify
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-14 00:00:00.000000000 Z
+date: 2013-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: wires
@@ -25,13 +25,27 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.2.8
 - !ruby/object:Gem::Dependency
-  name: rb-inotify~> 0.9.0
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -39,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -53,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: turn
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -66,13 +80,13 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Wires extension gem to integrate with inotify.
+description: Wires extension gem to integrate with inotify via rb-inotify.
 email: joe.eli.mac@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/wires-inotify.rb
+- lib/wires/inotify.rb
 homepage: https://github.com/jemc/wires-inotify/
 licenses:
 - 'Copyright (c) Joe McIlvain. All rights reserved '

data/lib/wires-inotify.rb

@@ -1,10 +0,0 @@
-require 'rb-inotify'
-
-module Wires
-  
-  class NotifyEvent < Event; end
-  
-  class Notifier
-  end
-  
-end