smparkes-watchr 0.5.7

data/lib/watchr/controller.rb

@@ -0,0 +1,93 @@
+module Watchr
+
+  class Refresh < Exception; end
+
+  # The controller contains the app's core logic.
+  #
+  # ===== Examples
+  #
+  #   script = Watchr::Script.new(file)
+  #   contrl = Watchr::Controller.new(script)
+  #   contrl.run
+  #
+  # Calling <tt>#run</tt> will enter the listening loop, and from then on every
+  # file event will trigger its corresponding action defined in <tt>script</tt>
+  #
+  # The controller also automatically adds the script's file itself to its list
+  # of monitored files and will detect any changes to it, providing on the fly
+  # updates of defined rules.
+  #
+  class Controller
+
+    def handler
+      @handler ||= begin
+                     handler = Watchr.handler.new
+                     handler.add_observer self
+                     Watchr.debug "using %s handler" % handler.class.name
+                     handler
+                   end
+      @handler
+    end
+
+    # Creates a controller object around given <tt>script</tt>
+    #
+    # ===== Parameters
+    # script<Script>:: The script object
+    #
+    def initialize(script)
+      @script  = script
+    end
+
+    # Enters listening loop.
+    #
+    # Will block control flow until application is explicitly stopped/killed.
+    #
+    def run
+      @script.parse!
+      handler.listen(monitored_paths)
+    rescue Interrupt
+    end
+
+    # Callback for file events.
+    #
+    # Called while control flow in in listening loop. It will execute the
+    # file's corresponding action as defined in the script. If the file is the
+    # script itself, it will refresh its state to account for potential changes.
+    #
+    # ===== Parameters
+    # path<Pathname, String>:: path that triggered event
+    # event<Symbol>:: event type (ignored for now)
+    #
+    def update(path, event_type = nil)
+      path = Pathname(path).expand_path
+      # p path, event_type
+      if path == @script.path && ![ :load, :deleted, :moved ].include?(event_type)
+        @script.parse!
+        handler.refresh(monitored_paths)
+      else
+        begin
+          @script.call_action_for(path, event_type)
+        rescue Refresh => refresh
+          handler.refresh(monitored_paths)
+        end
+      end
+    end
+
+    # List of paths the script is monitoring.
+    #
+    # Basically this means all paths below current directoly recursivelly that
+    # match any of the rules' patterns, plus the script file.
+    #
+    # ===== Returns
+    # paths<Array[Pathname]>:: List of monitored paths
+    #
+    def monitored_paths
+      paths = Dir['**/*'].select do |path|
+        @script.rules.any? {|r| r.match(path) }
+      end
+      paths.push(@script.path).compact!
+      paths.map {|path| Pathname(path).expand_path }
+    end
+  end
+end
+

data/lib/watchr/event_handlers/base.rb

@@ -0,0 +1,48 @@
+require 'observer'
+
+module Watchr
+  module EventHandler
+    class AbstractMethod < Exception #:nodoc:
+    end
+
+    # Base functionality mixin meant to be included in specific event handlers.
+    module Base
+      include Observable
+
+      # Notify that a file was modified.
+      #
+      # ===== Parameters
+      # path<Pathname, String>:: full path or path relative to current working directory
+      # event_type<Symbol>:: event type.
+      #--
+      # #changed and #notify_observers are Observable methods
+      def notify(path, event_type = nil)
+        changed(true)
+        notify_observers(path, event_type)
+      end
+
+      # Begin watching given paths and enter listening loop. Called by the controller.
+      #
+      # Abstract method
+      #
+      # ===== Parameters
+      # monitored_paths<Array(Pathname)>:: list of paths the application is currently monitoring.
+      #
+      def listen(monitored_paths)
+        raise AbstractMethod
+      end
+
+      # Called by the controller when the list of paths monitored by wantchr
+      # has changed. It should refresh the list of paths being watched.
+      #
+      # Abstract method
+      #
+      # ===== Parameters
+      # monitored_paths<Array(Pathname)>:: list of paths the application is currently monitoring.
+      #
+      def refresh(monitored_paths)
+        raise AbstractMethod
+      end
+    end
+  end
+end

data/lib/watchr/event_handlers/em.rb

@@ -0,0 +1,147 @@
+require "eventmachine"
+
+require 'watchr/event_handlers/unix'
+
+module Watchr
+  module EventHandler
+    class EM
+
+      Watchr::EventHandler::Unix.defaults << self
+      
+      ::EM.kqueue = true if ::EM.kqueue?
+      
+      ::EM.error_handler do |e|
+        puts "EM recevied: #{e.message}"
+        puts e.backtrace
+        exit
+      end
+
+      include Base
+
+      module SingleFileWatcher #:nodoc:
+        class << self
+          # Stores a reference back to handler so we can call its #nofity
+          # method with file event info
+          attr_accessor :handler
+        end
+
+        def init first_time
+          # p "w", path, first_time,(first_time ? :load : :created)
+          update_reference_times
+          SingleFileWatcher.handler.notify(path, (first_time ? :load : :created) )
+        end
+
+        # File's path as a Pathname
+        def pathname
+          @pathname ||= Pathname(path)
+        end
+
+        def file_modified
+          SingleFileWatcher.handler.notify(path, type)
+        end
+
+        def file_moved
+          stop_watching
+          SingleFileWatcher.handler.notify(path, type)
+        end
+
+        def file_deleted
+          stop_watching
+          SingleFileWatcher.handler.notify(path, type)
+        end
+
+        # Callback. Called on file change event
+        # Delegates to Controller#update, passing in path and event type
+        def on_change
+          self.class.handler.notify(path, type)
+          update_reference_times unless type == :deleted
+        end
+
+        private
+
+        def update_reference_times
+          @reference_atime = pathname.atime
+          @reference_mtime = pathname.mtime
+          @reference_ctime = pathname.ctime
+        end
+
+        # Type of latest event.
+        #
+        # A single type is determined, even though more than one stat times may
+        # have changed on the file. The type is the first to match in the
+        # following hierarchy:
+        #
+        #   :deleted, :modified (mtime), :accessed (atime), :changed (ctime)
+        #
+        # ===== Returns
+        # type<Symbol>:: latest event's type
+        #
+        def type
+          return :deleted   if !pathname.exist?
+          return :modified  if  pathname.mtime > @reference_mtime
+          return :accessed  if  pathname.atime > @reference_atime
+          return :changed   if  pathname.ctime > @reference_ctime
+        end
+      end
+
+      def initialize
+        SingleFileWatcher.handler = self
+        @old_paths = []
+        @first_time = true
+        @watchers = {}
+      end
+
+      # Enters listening loop.
+      #
+      # Will block control flow until application is explicitly stopped/killed.
+      #
+      def listen(monitored_paths)
+        @monitored_paths = monitored_paths
+        ::EM.run do
+          attach
+        end
+      end
+
+      # Rebuilds file bindings.
+      #
+      # will detach all current bindings, and reattach the <tt>monitored_paths</tt>
+      #
+      def refresh(monitored_paths)
+        @monitored_paths = monitored_paths
+        attach
+      end
+
+      private
+
+      # Binds all <tt>monitored_paths</tt> to the listening loop.
+      def attach
+        @monitored_paths = @monitored_paths.uniq 
+        new_paths = @monitored_paths - @old_paths
+        remove_paths = @old_paths - @monitored_paths
+        # p "want", @monitored_paths
+        # p "old", @old_paths
+        # p "new", new_paths
+        raise "hell" if @monitored_paths.length == 1
+        new_paths.each do |path|
+          ::EM.watch_file path.to_s, SingleFileWatcher do |watcher|
+            watcher.init @first_time
+            raise "hell" if @watchers[path]
+            @watchers[path] = watcher
+          end
+        end
+        remove_paths.each do |path|
+          watcher = @watchers[path]
+          raise "hell" if !watcher
+          watcher.stop
+        end
+        @old_paths = @monitored_paths
+        @first_time = false
+      end
+
+      # Unbinds all paths currently attached to listening loop.
+      def detach
+        @loop.watchers.each {|watcher| watcher.detach }
+      end
+    end
+  end
+end

data/lib/watchr/event_handlers/portable.rb

@@ -0,0 +1,60 @@
+module Watchr
+  module EventHandler
+    class Portable
+      include Base
+
+      def initialize
+        @reference_mtime = @reference_atime = @reference_ctime = Time.now
+      end
+
+      # Enters listening loop.
+      #
+      # Will block control flow until application is explicitly stopped/killed.
+      #
+      def listen(monitored_paths)
+        @monitored_paths = monitored_paths
+        loop { trigger; sleep(1) }
+      end
+
+      # See if an event occured, and if so notify observers.
+      def trigger #:nodoc:
+        path, type = detect_event
+        notify(path, type) unless path.nil?
+      end
+
+      # Update list of monitored paths.
+      def refresh(monitored_paths)
+        @monitored_paths = monitored_paths
+      end
+
+      private
+
+      # Verify mtimes of monitored files.
+      #
+      # If the latest mtime is more recent than the reference mtime, return
+      # that file's path.
+      #
+      # ===== Returns
+      # path and type of event if event occured, nil otherwise
+      #
+      #--
+      # OPTIMIZE, REFACTOR
+      def detect_event
+        @monitored_paths.each do |path|
+          return [path, :deleted] unless path.exist?
+        end
+
+        mtime_path = @monitored_paths.max {|a,b| a.mtime <=> b.mtime }
+        atime_path = @monitored_paths.max {|a,b| a.atime <=> b.atime }
+        ctime_path = @monitored_paths.max {|a,b| a.ctime <=> b.ctime }
+
+        if    mtime_path.mtime > @reference_mtime then @reference_mtime = mtime_path.mtime; [mtime_path, :modified]
+        elsif atime_path.atime > @reference_atime then @reference_atime = atime_path.atime; [atime_path, :accessed]
+        elsif ctime_path.ctime > @reference_ctime then @reference_ctime = ctime_path.ctime; [ctime_path, :changed ]
+        else; nil; end
+      rescue Errno::ENOENT => e
+        retry
+      end
+    end
+  end
+end

data/lib/watchr/event_handlers/rev.rb

@@ -0,0 +1,104 @@
+require "rev"
+
+require 'watchr/event_handlers/unix'
+
+module Watchr
+  module EventHandler
+    class Rev
+      
+      Watchr::EventHandler::Unix.defaults << self
+
+      include Base
+
+      # Used by Rev. Wraps a monitored path, and Rev::Loop will call its
+      # callback on file events.
+      class SingleFileWatcher < ::Rev::StatWatcher #:nodoc:
+        class << self
+          # Stores a reference back to handler so we can call its #nofity
+          # method with file event info
+          attr_accessor :handler
+        end
+
+        def initialize(path)
+          super
+          update_reference_times
+        end
+
+        # File's path as a Pathname
+        def pathname
+          @pathname ||= Pathname(@path)
+        end
+
+        # Callback. Called on file change event
+        # Delegates to Controller#update, passing in path and event type
+        def on_change
+          self.class.handler.notify(path, type)
+          update_reference_times unless type == :deleted
+        end
+
+        private
+
+        def update_reference_times
+          @reference_atime = pathname.atime
+          @reference_mtime = pathname.mtime
+          @reference_ctime = pathname.ctime
+        end
+
+        # Type of latest event.
+        #
+        # A single type is determined, even though more than one stat times may
+        # have changed on the file. The type is the first to match in the
+        # following hierarchy:
+        #
+        #   :deleted, :modified (mtime), :accessed (atime), :changed (ctime)
+        #
+        # ===== Returns
+        # type<Symbol>:: latest event's type
+        #
+        def type
+          return :deleted   if !pathname.exist?
+          return :modified  if  pathname.mtime > @reference_mtime
+          return :accessed  if  pathname.atime > @reference_atime
+          return :changed   if  pathname.ctime > @reference_ctime
+        end
+      end
+
+      def initialize
+        SingleFileWatcher.handler = self
+        @loop = ::Rev::Loop.default
+      end
+
+      # Enters listening loop.
+      #
+      # Will block control flow until application is explicitly stopped/killed.
+      #
+      def listen(monitored_paths)
+        @monitored_paths = monitored_paths
+        attach
+        @loop.run
+      end
+
+      # Rebuilds file bindings.
+      #
+      # will detach all current bindings, and reattach the <tt>monitored_paths</tt>
+      #
+      def refresh(monitored_paths)
+        @monitored_paths = monitored_paths
+        detach
+        attach
+      end
+
+      private
+
+      # Binds all <tt>monitored_paths</tt> to the listening loop.
+      def attach
+        @monitored_paths.each {|path| SingleFileWatcher.new(path.to_s).attach(@loop) }
+      end
+
+      # Unbinds all paths currently attached to listening loop.
+      def detach
+        @loop.watchers.each {|watcher| watcher.detach }
+      end
+    end
+  end
+end