fsevent 0.1 → 0.2

data/lib/fsevent/processdevice.rb

@@ -70,7 +70,7 @@ class FSEvent::ProcessDevice < FSEvent::AbstractDevice
       msgtype, *rest = Marshal.load(@io)
     end
     if msgtype != :return_to_parent
-      raise RuntimeError, "unexpected message type: #{msgtype.inspect}"
+      raise FSEvent::FSEventError, "unexpected message type: #{msgtype.inspect}"
     end
     rest[0]
   end

data/lib/fsevent/processdevicec.rb

@@ -25,8 +25,8 @@ class FSEvent::ProcessDeviceC < FSEvent::AbstractDevice
       @obj.call_parent(:add_watch, watchee_device_name, status_name)
     end
 
-    def status_changed(status_name, value)
-      @obj.call_parent(:status_changed, status_name, value)
+    def modify_status(status_name, value)
+      @obj.call_parent(:modify_status, status_name, value)
     end
   end
 
@@ -55,7 +55,7 @@ class FSEvent::ProcessDeviceC < FSEvent::AbstractDevice
       msgtype, *rest = Marshal.load(STDIN)
     end
     if msgtype != :return_to_child
-      raise RuntimeError, "unexpected message type: #{msgtype.inspect}"
+      raise FSEvent::FSEventError, "unexpected message type: #{msgtype.inspect}"
     end
     rest[0]
   end
@@ -69,7 +69,7 @@ class FSEvent::ProcessDeviceC < FSEvent::AbstractDevice
         exit true
       end
       if msgtype != :call_child
-        raise RuntimeError, "unexpected message type: #{msgtype.inspect}"
+        raise FSEvent::FSEventError, "unexpected message type: #{msgtype.inspect}"
       end
       method, *args = rest
       ret = this_device.send(method, *args)

data/lib/fsevent/simpledevice.rb

@@ -40,7 +40,7 @@ class FSEvent::SimpleDevice < FSEvent::AbstractDevice
     end
   end
 
-  def run(watched_status_change)
-    @run_block.call watched_status_change
+  def run(watched_status, changed_status)
+    @run_block.call watched_status, changed_status
   end
 end

data/lib/fsevent/util.rb

@@ -48,16 +48,46 @@ module FSEvent::Util
     end
   end
 
+  def valid_device_name_for_read?(str)
+    /\A_?[a-z][a-z0-9_]*\z/ =~ str
+  end
+
+  def valid_device_name_pat_for_read?(str)
+    /\A_?(?:[a-z][a-z0-9_]*)?\*?\z/ =~ str
+  end
+
+  def valid_status_name_for_read?(str)
+    /\A_?[a-z][a-z0-9_]*\z/ =~ str
+  end
+
+  def valid_status_name_pat_for_read?(str)
+    /\A_?(?:[a-z][a-z0-9_]*)?\*?\z/ =~ str
+  end
+
+  def valid_device_name_for_write?(str)
+    /\A[a-z][a-z0-9_]*\z/ =~ str
+  end
+
+  def valid_status_name_for_write?(str)
+    /\A[a-z][a-z0-9_]*\z/ =~ str
+  end
+
+  def prefixpat_match(pat, str)
+    if /\*\z/ =~ pat
+      str.start_with?($`)
+    else
+      pat == str
+    end
+  end
+
   def reaction_immediate_at_beginning?(reaction)
     case reaction
     when :immediate
       true
-    when :immediate_only_at_beginning
-      true
     when :schedule
       false
     else
-      raise "unexpected reaction: #{reaction.inspect}"
+      raise ArgumentError, "unexpected reaction: #{reaction.inspect}"
     end
   end
 
@@ -65,12 +95,10 @@ module FSEvent::Util
     case reaction
     when :immediate
       true
-    when :immediate_only_at_beginning
-      false
     when :schedule
       false
     else
-      raise "unexpected reaction: #{reaction.inspect}"
+      raise ArgumentError, "unexpected reaction: #{reaction.inspect}"
     end
   end
 

data/lib/fsevent/watchset.rb

@@ -0,0 +1,133 @@
+# watchset.rb --- set of watches
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class FSEvent::WatchSet
+  include FSEvent::Util
+
+  def initialize
+    # valid values of reaction: :immediate, :schedule
+    @watch_defs = nested_hash(3) # watcher_device_name -> watchee_device_name_pat -> status_name_pat -> reaction
+
+    @watch_exact_exact = nested_hash(3) # watchee_device_name_exact -> status_name_exact -> watcher_device_name -> reaction
+    @watch_exact_prefix = nested_hash(3) # watchee_device_name_exact -> status_name_prefix -> watcher_device_name -> reaction
+    @watch_prefix_exact = nested_hash(3) # watchee_device_name_prefix -> status_name_exact -> watcher_device_name -> reaction
+    @watch_prefix_prefix = nested_hash(3) # watchee_device_name_prefix -> status_name_prefix -> watcher_device_name -> reaction
+  end
+
+  def add(watchee_device_name_pat, status_name_pat, watcher_device_name, reaction)
+    @watch_defs[watcher_device_name][watchee_device_name_pat][status_name_pat] = reaction
+    if /\*\z/ =~ watchee_device_name_pat
+      watchee_device_name_prefix = $`
+      if /\*\z/ =~ status_name_pat
+        status_name_prefix = $`
+        @watch_prefix_prefix[watchee_device_name_prefix][status_name_prefix][watcher_device_name] = reaction
+      else
+        @watch_prefix_exact[watchee_device_name_prefix][status_name_pat][watcher_device_name] = reaction
+      end
+    else
+      if /\*\z/ =~ status_name_pat
+        status_name_prefix = $`
+        @watch_exact_prefix[watchee_device_name_pat][status_name_prefix][watcher_device_name] = reaction
+      else
+        @watch_exact_exact[watchee_device_name_pat][status_name_pat][watcher_device_name] = reaction
+      end
+    end
+  end
+
+  def del(watchee_device_name_pat, status_name_pat, watcher_device_name)
+    @watch_defs[watcher_device_name][watchee_device_name_pat].delete status_name_pat
+    if /\*\z/ =~ watchee_device_name_pat
+      watchee_device_name_prefix = $`
+      if /\*\z/ =~ status_name_pat
+        status_name_prefix = $`
+        @watch_prefix_prefix[watchee_device_name_prefix][status_name_prefix].delete watcher_device_name
+      else
+        @watch_prefix_exact[watchee_device_name_prefix][status_name_pat].delete watcher_device_name
+      end
+    else
+      if /\*\z/ =~ status_name_pat
+        status_name_prefix = $`
+        @watch_exact_prefix[watchee_device_name_pat][status_name_prefix].delete watcher_device_name
+      else
+        @watch_exact_exact[watchee_device_name_pat][status_name_pat].delete watcher_device_name
+      end
+    end
+  end
+
+  def lookup_watchers(watchee_device_name, status_name)
+    # needs cache for performance?
+    result = []
+    if @watch_exact_exact.has_key?(watchee_device_name) &&
+       @watch_exact_exact[watchee_device_name].has_key?(status_name)
+      @watch_exact_exact[watchee_device_name][status_name].each {|watcher_device_name, reaction|
+        result << [watcher_device_name, reaction]
+      }
+    end
+    if @watch_exact_prefix.has_key?(watchee_device_name)
+      @watch_exact_prefix[watchee_device_name].each {|status_name_prefix, h| # linear search.  can be slow.  binary search is better.
+        if status_name.start_with? status_name_prefix
+          h.each {|watcher_device_name, reaction|
+            result << [watcher_device_name, reaction]
+          }
+        end
+      }
+    end
+    @watch_prefix_exact.each {|watchee_device_name_prefix, h1| # linear search.  can be slow.  binary search is better.
+      next unless watchee_device_name.start_with? watchee_device_name_prefix
+      if @watch_prefix_exact[watchee_device_name_prefix].has_key?(status_name)
+        @watch_prefix_exact[watchee_device_name_prefix][status_name].each {|watcher_device_name, reaction|
+          result << [watcher_device_name, reaction]
+        }
+      end
+    }
+    @watch_prefix_prefix.each {|watchee_device_name_prefix, h1| # linear search.  can be slow.  binary search is better.
+      next unless watchee_device_name.start_with? watchee_device_name_prefix
+      @watch_prefix_prefix[watchee_device_name_prefix].each {|status_name_prefix, h| # linear search.  can be slow.  binary search is better.
+        if status_name.start_with? status_name_prefix
+          h.each {|watcher_device_name, reaction|
+            result << [watcher_device_name, reaction]
+          }
+        end
+      }
+    }
+    result
+  end
+
+  def watcher_each(watcher_device_name)
+    return unless @watch_defs.has_key? watcher_device_name
+    @watch_defs[watcher_device_name].each {|watchee_device_name_pat, h|
+      h.each {|status_name_pat, reaction|
+        yield watchee_device_name_pat, status_name_pat, reaction
+      }
+    }
+  end
+
+  def delete_watcher(watcher_device_name)
+    @watch_defs.delete watcher_device_name
+
+    [@watch_exact_exact,
+     @watch_exact_prefix,
+     @watch_prefix_exact,
+     @watch_prefix_prefix].each {|h0|
+      h0.each {|watchee_device_name, h1|
+        h1.each {|status_name, h2|
+          h2.delete watcher_device_name
+        }
+      }
+    }
+  end
+end

data/sample/repeat.rb

@@ -9,7 +9,7 @@ class Repeater < FSEvent::AbstractDevice
     @schedule = schedule
   end
 
-  def run(watched_status_change)
+  def run(watched_status, changed_status)
     @framework.set_elapsed_time(1)
     p @framework.current_time.iso8601(3)
   end

data/sample/repeat2.rb

@@ -8,7 +8,7 @@ class Repeater < FSEvent::AbstractDevice
     @schedule = schedule
   end
 
-  def run(watched_status_change)
+  def run(watched_status, changed_status)
     p [self.name, @framework.current_time]
   end
 end

data/test/test_failsafedevice.rb

@@ -35,10 +35,10 @@ class TestFSEventFailSafeDevice < Test::Unit::TestCase
       define_status("s", @init)
     end
 
-    def run(watched_status_change)
+    def run(watched_status, changed_status)
       @test_result << [@framework.current_time, @values.first]
       set_elapsed_time(@elapsed)
-      status_changed "s", @values.shift
+      modify_status "s", @values.shift
     end
   end
 
@@ -68,9 +68,9 @@ class TestFSEventFailSafeDevice < Test::Unit::TestCase
       set_elapsed_time(1)
     end
 
-    def run(watched_status_change)
+    def run(watched_status, changed_status)
       set_elapsed_time(1)
-      super(watched_status_change)
+      super(watched_status, changed_status)
     end
   end
 
@@ -89,9 +89,9 @@ class TestFSEventFailSafeDevice < Test::Unit::TestCase
       add_watch(@watchee_device_name, @watchee_status)
     end
 
-    def run(watched_status_change)
+    def run(watched_status, changed_status)
       set_elapsed_time(1)
-      @test_result << [@framework.current_time, watched_status_change]
+      @test_result << [@framework.current_time, watched_status]
     end
   end
 

data/test/test_framework.rb

@@ -36,6 +36,7 @@ class TestFSEventFramework < Test::Unit::TestCase
   def test_inactive_device
     fsevent = FSEvent.new
     device = FSEvent::AbstractDevice.new("test_inactive_device")
+    fsevent.register_device device
     assert_nothing_raised { fsevent.start }
   end
 
@@ -45,13 +46,13 @@ class TestFSEventFramework < Test::Unit::TestCase
     fsevent = FSEvent.new(t0)
     device = TDevice.new("test_single_run")
     device.schedule.merge_schedule([t1])
-    def device.run(watched_status_change)
+    def device.run(watched_status, changed_status)
       @test_result << @framework.current_time
-      @test_result << watched_status_change
+      @test_result << watched_status
     end
     fsevent.register_device(device)
     assert_nothing_raised { fsevent.start }
-    assert_equal([t1, nil], device.test_result)
+    assert_equal([t1, {}], device.test_result)
   end
 
   def test_double_run
@@ -61,13 +62,13 @@ class TestFSEventFramework < Test::Unit::TestCase
     fsevent = FSEvent.new(t0)
     device = TDevice.new("test_double_run")
     device.schedule.merge_schedule([t1, t2])
-    def device.run(watched_status_change)
+    def device.run(watched_status, changed_status)
       @test_result << @framework.current_time
-      @test_result << watched_status_change
+      @test_result << watched_status
     end
     fsevent.register_device(device)
     assert_nothing_raised { fsevent.start }
-    assert_equal([t1, nil, t2, nil], device.test_result)
+    assert_equal([t1, {}, t2, {}], device.test_result)
   end
 
   def test_repeated_run
@@ -77,7 +78,7 @@ class TestFSEventFramework < Test::Unit::TestCase
     device = TDevice.new("test_repeated_run")
     schedule = FSEvent::PeriodicSchedule.new(t1, 3)
     device.schedule.merge_schedule(schedule)
-    def device.run(watched_status_change)
+    def device.run(watched_status, changed_status)
       @test_result << @framework.current_time
       @schedule = [] if 2 < @test_result.length
     end
@@ -93,12 +94,12 @@ class TestFSEventFramework < Test::Unit::TestCase
     fsevent = FSEvent.new(t0)
     device1 = TDevice.new("test_twodevice_1")
     device1.schedule.merge_schedule([t1])
-    def device1.run(watched_status_change)
+    def device1.run(watched_status, changed_status)
       @test_result << @framework.current_time
     end
     device2 = TDevice.new("test_twodevice_2")
     device2.schedule.merge_schedule([t2])
-    def device2.run(watched_status_change)
+    def device2.run(watched_status, changed_status)
       @test_result << @framework.current_time
     end
     fsevent.register_device(device1)
@@ -108,13 +109,45 @@ class TestFSEventFramework < Test::Unit::TestCase
     assert_equal([t2], device2.test_result)
   end
 
+  def test_negative_elapsed_time
+    t = Time.utc(2000)
+    fse = FSEvent.new(t)
+    d = FSEvent::AbstractDevice.new("d")
+    def d.registered
+      set_elapsed_time(-1)
+    end
+    fse.register_device d
+    assert_raise(ArgumentError) { fse.start }
+  end
+
+  def test_undefine_status
+    t = Time.utc(2000)
+    fse = FSEvent.new(t)
+    d1 = FSEvent::SimpleDevice.new("d1", {"s"=>0}, [], 5, [t+10]) {|watched_status, changed_status|
+      fse.undefine_status("s")
+      fse.set_elapsed_time(1)
+    }
+    result = []
+    d2 = FSEvent::SimpleDevice.new("d2", {}, [["d1", "s", :immediate]], 1) {|watched_status, changed_status|
+      result << [fse.current_time, watched_status, changed_status]
+      fse.set_elapsed_time(1)
+    }
+    fse.register_device d1
+    fse.register_device d2
+    fse.start
+    assert_equal(
+      [[t+5, {"d1"=>{"s"=>0}}, {"d1"=>{"s"=>t+5}}],
+       [t+11, {"d1"=>{}}, {"d1"=>{"s"=>t+11}}]],
+       result)
+  end
+
   def test_unregister_in_sleeping
     t0 = Time.utc(2000)
     fsevent = FSEvent.new(t0)
     sched1 = FSEvent::PeriodicSchedule.new(t0+10,5)
     result = []
     device1 = FSEvent::SimpleDevice.new("target", {}, [], 1, sched1) {
-      |watched_status_change|
+      |watched_status, changed_status|
       result << fsevent.current_time
       fsevent.set_elapsed_time(2)
     }
@@ -133,7 +166,7 @@ class TestFSEventFramework < Test::Unit::TestCase
     sched1 = FSEvent::PeriodicSchedule.new(t0+10,5)
     result = []
     device1 = FSEvent::SimpleDevice.new("target", {}, [], 1, sched1) {
-      |watched_status_change|
+      |watched_status, changed_status|
       result << fsevent.current_time
       fsevent.set_elapsed_time(2)
     }
@@ -152,7 +185,7 @@ class TestFSEventFramework < Test::Unit::TestCase
     sched1 = FSEvent::PeriodicSchedule.new(t0+10,5)
     result = []
     device1 = FSEvent::SimpleDevice.new("target", {}, [], 1, sched1) {
-      |watched_status_change|
+      |watched_status, changed_status|
       result << fsevent.current_time
       if fsevent.current_time == t0+20
         fsevent.unregister_device("target")
@@ -164,4 +197,147 @@ class TestFSEventFramework < Test::Unit::TestCase
     assert_equal([t0+10,t0+15,t0+20], result)
   end
 
+  def test_unregister_time
+    t = Time.utc(2000)
+    fse = FSEvent.new(t)
+    d1 = FSEvent::SimpleDevice.new("d1", {"s"=>0}, [], 5, [t+10]) {|watched_status, changed_status|
+      fse.unregister_device("d1")
+      fse.set_elapsed_time(1)
+    }
+    result = []
+    d2 = FSEvent::SimpleDevice.new("d2", {}, [["d1", "s", :immediate]], 1) {|watched_status, changed_status|
+      result << [fse.current_time, watched_status, changed_status]
+      fse.set_elapsed_time(1)
+    }
+    fse.register_device d1
+    fse.register_device d2
+    fse.start
+    assert_equal(
+      [[t+5, {"d1"=>{"s"=>0}}, {"d1"=>{"s"=>t+5}}],
+       [t+11, {"d1"=>{}}, {"d1"=>{"s"=>t+11}}]],
+       result)
+  end
+
+  def test_clock_proc
+    t = Time.utc(2000)
+    fse = FSEvent.new(t)
+    d = FSEvent::SimpleDevice.new("d1", {"s"=>0}, [], 5, [t+20, t+32]) {|watched_status, changed_status|
+      fse.set_elapsed_time(1)
+    }
+    fse.register_device d
+    result = []
+    fse.clock_proc = lambda {|current_time, next_time|
+      result << next_time - current_time
+    }
+    fse.start
+    assert_equal([5, 15, 1, 11, 1], result)
+  end
+
+  def test_device_registered1
+    t = Time.utc(2000)
+    fse = FSEvent.new(t)
+    #fse.register_device FSEvent::DebugDumper.new
+    d11 = FSEvent::SimpleDevice.new("d1", {}, [], 1, [t+19, t+29, t+39, t+49]) {|watched_status, changed_status|
+      case fse.current_time
+      when t+10
+      when t+19
+        fse.define_status("s", 100)
+      when t+29
+        fse.undefine_status("s")
+      when t+39
+        fse.define_status("s", 200)
+      when t+49
+        fse.unregister_device("d1")
+      else
+        raise "unexpected time"
+      end
+      fse.set_elapsed_time(1)
+    }
+    d12 = FSEvent::SimpleDevice.new("d1", {}, [], 1, []) {|watched_status, changed_status|
+      fse.set_elapsed_time(1)
+    }
+    d0 = FSEvent::SimpleDevice.new("d0", {}, [], 1, [t+9, t+59]) {|watched_status, changed_status|
+      fse.set_elapsed_time(1)
+      case fse.current_time
+      when t+9
+        fse.register_device d11
+      when t+59
+        fse.register_device d12
+      else
+        raise "unexpected wakeup d0"
+      end
+    }
+    times = []
+    d2 = FSEvent::SimpleDevice.new("d2", {},
+                                   [["_fsevent", "_device_registered_d1", :immediate],
+                                    ["_fsevent", "_device_unregistered_d1", :immediate],
+                                    ["d1", "_status_defined_s", :immediate],
+                                    ["d1", "_status_undefined_s", :immediate],
+                                    ["d1", "s", :immediate]],
+                                   1, [t+5]) {|watched_status, changed_status|
+      case fse.current_time
+      when t+5
+        assert_equal({"_fsevent"=>{}, "d1"=>{}}, watched_status)
+        assert_equal({"_fsevent"=>{}, "d1"=>{}}, changed_status)
+      when t+11
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+11}, "d1"=>{}}, watched_status)
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+11}, "d1"=>{}}, changed_status)
+      when t+20
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+11}, "d1"=>{"s"=>100, "_status_defined_s"=>t+20}}, watched_status)
+        assert_equal({"_fsevent"=>{}, "d1"=>{"s"=>t+20, "_status_defined_s"=>t+20}}, changed_status)
+      when t+30
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+11}, "d1"=>{"_status_defined_s"=>t+20, "_status_undefined_s"=>t+30}}, watched_status)
+        assert_equal({"_fsevent"=>{}, "d1"=>{"s"=>t+30, "_status_undefined_s"=>t+30}}, changed_status)
+      when t+40
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+11}, "d1"=>{"s"=>200, "_status_defined_s"=>t+40, "_status_undefined_s"=>t+30}}, watched_status)
+        assert_equal({"_fsevent"=>{}, "d1"=>{"s"=>t+40, "_status_defined_s"=>t+40}}, changed_status)
+      when t+50
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+11, "_device_unregistered_d1"=>t+50}, "d1"=>{}}, watched_status)
+        assert_equal({"_fsevent"=>{"_device_unregistered_d1"=>t+50}, "d1"=>{"s"=>t+50, "_status_undefined_s"=>t+50}}, changed_status)
+      when t+61
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+61, "_device_unregistered_d1"=>t+50}, "d1"=>{}}, watched_status)
+        assert_equal({"_fsevent"=>{"_device_registered_d1"=>t+61}, "d1"=>{}}, changed_status)
+      else
+        raise "unexpected wakeup d2 #{fse.current_time}"
+      end
+      times << fse.current_time
+      fse.set_elapsed_time(1)
+    }
+    fse.register_device d0
+    fse.register_device d2
+    fse.start
+    assert_equal([t+5, t+11, t+20, t+30, t+40, t+50, t+61], times)
+  end
+
+  def test_valid_name_for_write
+    t = Time.utc(2000)
+    fse = FSEvent.new(t)
+    assert_raise(ArgumentError) {
+      d = FSEvent::AbstractDevice.new("_d")
+      fse.register_device(d)
+    }
+    assert_raise(ArgumentError) { fse.define_status("_s", 0) }
+    assert_raise(ArgumentError) { fse.modify_status("_s", 0) }
+    assert_raise(ArgumentError) { fse.undefine_status("_s") }
+    assert_raise(ArgumentError) { fse.unregister_device("_d") }
+
+  end
+
+  def test_register_time
+    t = Time.utc(2000)
+    fse = FSEvent.new(t)
+    result = []
+    d1 = FSEvent::SimpleDevice.new("d1", {}, [], 1, [t+10]) {|watched_status, changed_status|
+      fse.set_elapsed_time(10)
+      d2 = FSEvent::AbstractDevice.new("d2")
+      class << d2; self end.send(:define_method, :registered) {
+        result << fse.current_time
+      }
+      fse.register_device(d2)
+    }
+    fse.register_device d1
+    fse.start
+    assert_equal([t+20], result)
+  end
+
 end