wake 0.1.0

data/lib/wake/controller.rb

@@ -0,0 +1,112 @@
+module Wake
+
+  class Refresh < Exception; end
+
+  # The controller contains the app's core logic.
+  #
+  # ===== Examples
+  #
+  #   script = Wake::Script.new(file)
+  #   contrl = Wake::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 = Wake.handler.new
+                     handler.add_observer self
+                     Wake.debug "using %s handler" % handler.class.name
+                     Script.handler = handler
+                     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|
+        watch = false
+        @script.rules.reverse.each do |r|
+          rule_watches = r.watch(path)
+          if false
+            $stderr.print "watch ", path, " ", rule_watches, "\n"
+          end
+          next if rule_watches.nil?
+          watch = rule_watches
+          break
+        end
+        watch
+      end
+      paths.each do |path|
+        # $stderr.print "lookup #{path}\n"
+        @script.depends_on(path).each do |dependence|
+          # $stderr.print "add #{dependence} for #{path}\n"
+          paths << dependence
+        end
+      end
+      paths.push(@script.path).compact!
+      paths.uniq!
+      # $stderr.print "watch #{paths.map {|path| Pathname(path).expand_path }.join(' ')}\n"
+      paths.map {|path| Pathname(path).expand_path }
+    end
+  end
+end

data/lib/wake/event_handlers/base.rb

@@ -0,0 +1,48 @@
+require 'observer'
+
+module Wake
+  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/wake/event_handlers/em.rb

@@ -0,0 +1,232 @@
+require "eventmachine"
+
+require 'wake/event_handlers/unix'
+require 'wake/event_handlers/base'
+
+module Wake
+  module EventHandler
+    class EM
+
+      Wake::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, event
+          # p "w", path, first_time,(first_time ? :load : :created)
+          # $stderr.puts "#{signature}: #{pathname}"
+          update_reference_times
+          # FIX: doesn't pass events
+          if !event
+            SingleFileWatcher.handler.notify(pathname, (first_time ? :load : :created) )
+          end
+        end
+
+        # File's path as a Pathname
+        def pathname
+          @pathname ||= Pathname(path)
+        end
+
+        def file_modified
+          # p "mod", pathname, type
+          SingleFileWatcher.handler.notify(pathname, type)
+          update_reference_times
+        end
+
+        def file_moved
+          # p "mov", pathname
+          SingleFileWatcher.handler.forget self, pathname
+          begin
+            # $stderr.puts "stop.fm #{signature}: #{pathname}"
+            stop_watching
+          rescue Exception => e
+            $stderr.puts "exception while attempting to stop_watching in file_moved: #{e}"
+          end
+          SingleFileWatcher.handler.notify(pathname, type)
+        end
+
+        def file_deleted
+          # p "del", pathname
+          # $stderr.puts "stop.fd #{signature}: #{pathname} #{type}"
+          SingleFileWatcher.handler.forget self, pathname
+          SingleFileWatcher.handler.notify(pathname, :deleted)
+          if type == :modified
+            # There's a race condition here ... the directory should have gotten mod'ed, but we'll get the
+            # delete after the directory scan, so we won't watch the new file. This isn't the cleanest way to
+            # handle this, but should work for now ...
+            SingleFileWatcher.handler.watch pathname
+          else
+          end
+        end
+
+        def stop
+          #  p "stop", pathname
+          begin
+            # $stderr.puts "stop.s #{signature}: #{pathname}"
+            stop_watching
+          rescue Exception => e
+            $stderr.puts "exception while attempting to stop_watching in stop: #{e}"
+          end
+        end
+
+        private
+
+        def update_reference_times
+          begin
+            @reference_atime = pathname.atime
+            @reference_mtime = pathname.mtime
+            @reference_ctime = pathname.ctime
+          rescue Exception; end
+        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 = {}
+        @attaching = false
+      end
+
+      # Enters listening loop.
+      #
+      # Will block control flow until application is explicitly stopped/killed.
+      #
+      def listen(monitored_paths)
+        # FIX ... make more generic (handle at a higher level ...)
+        while true
+          @monitored_paths = monitored_paths
+          @old_paths = []
+          @first_time = true
+          @watchers = {}
+          ::EM.run do
+            attach
+            if Wake.options.once
+              Wake.batches.each do |k,v|
+                k.deliver
+              end
+              return 
+            end
+          end
+        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
+
+      def forget connection, path
+        if @watchers[path] != connection
+          $stderr.puts \
+            "warning: no/wrong watcher to forget for #{path}: #{@watchers[path]} vs #{connection}"
+        end
+        @watchers.delete path
+        raise "hell: #{path}" if !@old_paths.include? Pathname(path)
+        @old_paths.delete Pathname(path)
+      end
+
+      def watch path, event = nil
+        begin
+          # p "watch", path, @first_time
+          ::EM.watch_file path.to_s, SingleFileWatcher do |watcher|
+            watcher.init @first_time, event
+            @watchers[path] = watcher
+          end
+          @old_paths << path
+        rescue Errno::ENOENT => e
+          $stderr.puts e
+        rescue Exception => e
+          $stderr.puts e
+        end
+      end  
+
+      def add path
+        # $stderr.print  "new #{path}\n"
+        if false && !@monitored_paths.include?( path )
+          $stderr.print "new #{path}\n"
+        end
+        @monitored_paths << path
+        # $stderr.print "add #{path.inspect}\n"
+        attach :dependence
+      end
+
+      private
+
+      # Binds all <tt>monitored_paths</tt> to the listening loop.
+      def attach event = nil
+        return if @attaching
+        @attaching = true
+        new_paths = nil
+        remove_paths = nil
+        begin
+          @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|
+            if @watchers[path]
+              $stderr.puts "warning: replacing (ignoring) watcher for #{path}"
+              @watchers[path].stop
+            end
+            watch path, event
+          end
+          remove_paths.each do |path|
+            watcher = @watchers[path]
+            watcher.stop if watcher
+            @watchers.delete path
+          end
+          @old_paths = @monitored_paths.dup
+          # $stderr.print "#{new_paths} #{remove_paths}\n";
+        end while !new_paths.empty? and !remove_paths.empty?
+        @first_time = false
+        @attaching = false
+      end
+
+      # Unbinds all paths currently attached to listening loop.
+      def detach
+        @loop.watchers.each {|watcher| watcher.detach }
+      end
+    end
+
+  end
+end

data/lib/wake/event_handlers/portable.rb

@@ -0,0 +1,60 @@
+module Wake
+  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