smparkes-watchr 0.5.7.4 → 0.5.7.6

data/README.rdoc

@@ -62,7 +62,7 @@ while looking at file paths: only directories will get watches put on
 them. (Otherwise <tt>%r(.*)</tt> would put watches on every
 file/directory in the tree, which seems kinda bad.)
 
-The second watch looks for HAML files in my public directory and
+The second watch looks for Haml files in my public directory and
 automatically converts them to HTML. These are static files, not
 served by an app server like Rails: even with static files, I hate
 writing raw HTML. The extension here is that instead of a single event
@@ -78,11 +78,13 @@ interested). This case is similar to the previous but also adds the
 seen after watchr starts. This allows watchr to run all the specs when
 first started, similar to what autotest does.
 
-=== Things to do
+=== Recent Changes
+
+1. POC for batch events that occur within a time window
 
-1. Batch up specs instead of running them individually (not a big deal for jazrb and haml; a big detail for rspec)
+1. Pass event type to callbacks
 
-1. Filter spec runs that run as individual commands so they look like a single command (requires batching)
+=== Things to do
 
 1. Integrate upstream (if they want it)
 
@@ -90,6 +92,6 @@ first started, similar to what autotest does.
 
 1. Handle user interrupt processing more systematically
 
-1. Perhaps add the event type to the watch callback, since multiple events can fire now. But haven't neede this.
+1. Don't swallow config file error messages, particularly on reload. Is this still happening?
 
-1. Don't swallow config file error messages (particularly on reload)
+1. Implement some kind of dependence detection (probably starting to get into plugin territory)

data/bin/watchr

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+$VERBOSE = true
+
 require 'pathname'
 require 'optparse'
 

data/lib/watchr.rb

@@ -25,9 +25,6 @@ module Watchr
   end
 
   class << self
-    attr_accessor :options
-    attr_accessor :handler
-
     # backwards compatibility
     def version #:nodoc:
       Watchr::VERSION

data/lib/watchr/controller.rb

@@ -28,7 +28,7 @@ module Watchr
                    end
       @handler
     end
-
+    
     # Creates a controller object around given <tt>script</tt>
     #
     # ===== Parameters
@@ -83,11 +83,20 @@ module Watchr
     #
     def monitored_paths
       paths = Dir['**/*'].select do |path|
-        @script.rules.any? {|r| r.match(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.push(@script.path).compact!
       paths.map {|path| Pathname(path).expand_path }
     end
   end
 end
-

data/lib/watchr/event_handlers/em.rb

@@ -27,8 +27,9 @@ module Watchr
 
         def init first_time
           # p "w", path, first_time,(first_time ? :load : :created)
+          # $stderr.puts "#{signature}: #{pathname}"
           update_reference_times
-          SingleFileWatcher.handler.notify(path, (first_time ? :load : :created) )
+          SingleFileWatcher.handler.notify(pathname, (first_time ? :load : :created) )
         end
 
         # File's path as a Pathname
@@ -37,23 +38,45 @@ module Watchr
         end
 
         def file_modified
-          SingleFileWatcher.handler.notify(path, type)
+          # p "mod", pathname, type
+          SingleFileWatcher.handler.notify(pathname, type)
           update_reference_times
         end
 
         def file_moved
-          SingleFileWatcher.handler.forget self, path
-          stop_watching
-          SingleFileWatcher.handler.notify(path, type)
+          # 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
-          SingleFileWatcher.handler.forget self, path
-          SingleFileWatcher.handler.notify(path, type)
+          # 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
-          stop_watching
+          #  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
@@ -122,12 +145,25 @@ module Watchr
             "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
+        begin
+          ::EM.watch_file path.to_s, SingleFileWatcher do |watcher|
+            watcher.init @first_time
+            @watchers[path] = watcher
+          end
+          @old_paths << path
+        rescue Errno::ENOENT; end
+      end  
+
       private
 
       # Binds all <tt>monitored_paths</tt> to the listening loop.
       def attach
+        # p "scan"
         @monitored_paths = @monitored_paths.uniq 
         new_paths = @monitored_paths - @old_paths
         remove_paths = @old_paths - @monitored_paths
@@ -138,12 +174,9 @@ module Watchr
         new_paths.each do |path|
           if @watchers[path]
             $stderr.puts "warning: replacing (ignoring) watcher for #{path}"
-            # @watchers[path].stop
-          end
-          ::EM.watch_file path.to_s, SingleFileWatcher do |watcher|
-            watcher.init @first_time
-            @watchers[path] = watcher
+            @watchers[path].stop
           end
+          watch path
         end
         remove_paths.each do |path|
           watcher = @watchers[path]
@@ -159,5 +192,6 @@ module Watchr
         @loop.watchers.each {|watcher| watcher.detach }
       end
     end
+
   end
 end

data/lib/watchr/script.rb

@@ -10,6 +10,31 @@ module Watchr
   class Script
     DEFAULT_EVENT_TYPE = :modified
 
+    class Batch
+      def initialize rule
+        @timer = nil
+        @rule = rule
+        @events = []
+      end
+
+      def call data, event
+        if @timer
+          @timer.cancel
+        end
+        @timer = EM::Timer.new(0.001) do
+          deliver
+        end
+        @events << [ data, event ]
+      end
+
+      def deliver
+        events = @events
+        @timer = nil
+        @events = []
+        @rule.action.call [events]
+      end
+    end
+
     # Convenience type. Provides clearer and simpler access to rule properties.
     #
     # ===== Examples
@@ -18,15 +43,38 @@ module Watchr
     #   rule.pattern      #=> 'lib/.*\.rb'
     #   rule.action.call  #=> 'ohaie'
     #
-    Rule = Struct.new(:pattern, :event_types, :predicate, :action)
+    Rule = Struct.new(:pattern, :event_types, :predicate, :options, :action, :batch)
 
     class Rule
+
+      def call data, event
+        if options[:batch]
+          self.batch ||= Batch.new self
+          batch.call data, event
+        else
+          action.call data, event
+        end
+      end
+
+      def watch path
+        watch = nil
+        pattern = self.pattern
+        ( pattern.class == String ) and ( pattern = Regexp.new pattern )
+        md = pattern.match(path)
+        if md
+          watch = self.predicate.nil? || self.predicate.call(md)
+        end
+        return watch
+      end
+
       def match path
         pattern = self.pattern
         ( pattern.class == String ) and ( pattern = Regexp.new pattern )
+        # p path, pattern, pattern.match(path)
         ( md = pattern.match(path) ) &&
           ( self.predicate == nil || self.predicate.call(md) )
       end
+
     end
     
     # TODO eval context
@@ -87,9 +135,9 @@ module Watchr
     # ===== Returns
     # rule<Rule>:: rule created by the method
     #
-    def watch(pattern, event_type = DEFAULT_EVENT_TYPE, predicate  = nil, &action)
+    def watch(pattern, event_type = DEFAULT_EVENT_TYPE, predicate = nil, options = {}, &action)
       event_types = Array(event_type)
-      @rules << Rule.new(pattern, event_types, predicate, action || @default_action)
+      @rules << Rule.new(pattern, event_types, predicate, options, action || @default_action)
       @rules.last
     end
 
@@ -137,8 +185,8 @@ module Watchr
       (1..10).each do
         old_v = v
         v = @path.read
-        break if v && v == old_v
-        sleep(0.2)
+        break if v != "" && v == old_v
+        sleep(0.3)
       end
 
       instance_eval(@path.read)
@@ -173,7 +221,7 @@ module Watchr
         types.each do |rule_event_type|
           if ( rule_event_type.nil? && ( event_type != :load ) ) || ( rule_event_type == event_type )
             data = path.match(rule.pattern)
-            return rule.action.call(data)
+            return rule.call(data, event_type)
           end
         end
       end
@@ -215,6 +263,11 @@ module Watchr
     # rules<Array(Rule)>:: rules corresponding to <tt>path</tt>
     #
     def rules_for(path)
+      @rules.reverse.select do |rule|
+        # p "K", path, rule.pattern, path.match(rule.pattern)
+        path.match(rule.pattern)
+      end
+      # p "KK", path, @rules.reverse.select {|rule| path.match(rule.pattern) }
       @rules.reverse.select {|rule| path.match(rule.pattern) }
     end
 

data/watchr.gemspec

@@ -1,7 +1,7 @@
 
 Gem::Specification.new do |s|
   s.name              = 'smparkes-watchr'
-  s.version           = '0.5.7.4'
+  s.version           = '0.5.7.6'
   s.summary           = "Modern continious testing (flexible alternative to autotest)"
   s.description       = "Modern continious testing (flexible alternative to autotest)."
   s.author            = "mynyml"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: smparkes-watchr
 version: !ruby/object:Gem::Version 
-  version: 0.5.7.4
+  version: 0.5.7.6
 platform: ruby
 authors: 
 - mynyml
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-02 00:00:00 -08:00
+date: 2009-11-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency