mynyml-watchr 0.3.0 → 0.5.2

data/specs.watchr

@@ -2,6 +2,9 @@
 #
 #   $ watchr specs.watchr
 
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
 def all_test_files
   Dir['test/**/test_*.rb'] - ['test/test_helper.rb']
 end
@@ -12,24 +15,30 @@ def run(cmd)
 end
 
 def run_all_tests
-  cmd = "ruby -rubygems -I.:lib:test -e'%w( #{all_test_files.join(' ')} ).each {|file| require file }'"
+  cmd = "ruby -rubygems -Ilib -e'%w( #{all_test_files.join(' ')} ).each {|file| require file }'"
   run(cmd)
 end
 
-watch( 'test/test_.*\.rb' )     {|md| run("ruby -rubygems #{md[0]}") }
-watch( 'lib/(.*)\.rb' )         {|md| run("ruby -rubygems test/test_#{md[1]}.rb") }
-watch( 'test/test_helper\.rb' ) { run_all_tests }
-
-# Ctrl-C
-Signal.trap('INT') do
-  puts " RERUNING ALL TESTS (Ctrl-\\ to quit)\n\n"
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch( '^test.*/test_.*\.rb'                  )   { |m| run( "ruby -rubygems %s"              % m[0] ) }
+watch( '^lib/(.*)\.rb'                        )   { |m| run( "ruby -rubygems test/test_%s.rb" % m[1] ) }
+watch( '^lib/watchr/(.*)\.rb'                 )   { |m| run( "ruby -rubygems test/test_%s.rb" % m[1] ) }
+watch( '^lib/watchr/event_handlers/(.*)\.rb'  )   { |m| run( "ruby -rubygems test/event_handlers/test_%s.rb" % m[1] ) }
+watch( '^test/test_helper\.rb'                )   { run_all_tests }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts " --- Running all tests ---\n\n"
   run_all_tests
 end
 
-# Ctrl-\
-Signal.trap('QUIT') { abort("\n") }
-
-
+# Ctrl-C
+Signal.trap('INT') { abort("\n") }
 
 
 # vim:ft=ruby

data/test/event_handlers/test_base.rb

@@ -0,0 +1,24 @@
+require 'test/test_helper'
+
+class BaseEventHandlerTest < Test::Unit::TestCase
+
+  class Handler
+    include Watchr::EventHandler::Base
+  end
+
+  def setup
+    @handler = Handler.new
+  end
+
+  test "api" do
+    @handler.should respond_to(:notify)
+    @handler.should respond_to(:listen)
+    @handler.should respond_to(:refresh)
+    @handler.class.ancestors.should include(Observable)
+  end
+
+  test "notifies observers" do
+    @handler.expects(:notify_observers).with('foo/bar', nil)
+    @handler.notify('foo/bar', nil)
+  end
+end

data/test/event_handlers/test_portable.rb

@@ -0,0 +1,58 @@
+require 'test/test_helper'
+
+class UnixEventHandlerTest < Test::Unit::TestCase
+  include Watchr
+
+  def setup
+    @handler = EventHandler::Portable.new
+    @handler.stubs(:loop)
+
+    @foo = Pathname('foo').expand_path
+    @bar = Pathname('bar').expand_path
+    @baz = Pathname('baz').expand_path
+    @bax = Pathname('bax').expand_path
+
+    @foo.stubs(:mtime).returns(Time.now - 100)
+    @bar.stubs(:mtime).returns(Time.now - 100)
+    @baz.stubs(:mtime).returns(Time.now - 100)
+    @bax.stubs(:mtime).returns(Time.now - 100)
+  end
+
+  test "triggers listening state" do
+    @handler.expects(:loop)
+    @handler.listen([])
+  end
+
+  ## monitoring file events
+
+  test "listens for events on monitored files" do
+    @handler.listen [ @foo, @bar ]
+    @handler.monitored_paths.should include(@foo)
+    @handler.monitored_paths.should include(@bar)
+  end
+
+  test "notifies observers on file event" do
+    @foo.stubs(:mtime).returns(Time.now + 100) # fake event
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :changed)
+    @handler.trigger
+  end
+
+  test "doesn't trigger on start" do
+  end
+
+  ## on the fly updates of monitored files list
+
+  test "reattaches to new monitored files" do
+    @handler.listen [ @foo, @bar ]
+    @handler.monitored_paths.should include(@foo)
+    @handler.monitored_paths.should include(@bar)
+
+    @handler.refresh [ @baz, @bax ]
+    @handler.monitored_paths.should include(@baz)
+    @handler.monitored_paths.should include(@bax)
+    @handler.monitored_paths.should exclude(@foo)
+    @handler.monitored_paths.should exclude(@bar)
+  end
+end

data/test/event_handlers/test_unix.rb

@@ -0,0 +1,56 @@
+require 'test/test_helper'
+
+class UnixEventHandlerTest < Test::Unit::TestCase
+  include Watchr
+
+  SingleFileWatcher = EventHandler::Unix::SingleFileWatcher
+
+  def setup
+    @loop    = Rev::Loop.default
+    @handler = EventHandler::Unix.new
+    @loop.stubs(:run)
+  end
+
+  def teardown
+    SingleFileWatcher.handler = nil
+    Rev::Loop.default.watchers.every.detach
+  end
+
+  test "triggers listening state" do
+    @loop.expects(:run)
+    @handler.listen([])
+  end
+
+  ## monitoring file events
+
+  test "listens for events on monitored files" do
+    @handler.listen %w( foo bar )
+    @loop.watchers.size.should be(2)
+    @loop.watchers.every.path.should include('foo', 'bar')
+    @loop.watchers.every.class.uniq.should be([SingleFileWatcher])
+  end
+
+  test "notifies observers on file event" do
+    watcher = SingleFileWatcher.new('foo/bar')
+    watcher.stubs(:path).returns('foo/bar')
+
+    @handler.expects(:notify).with('foo/bar', :changed)
+    watcher.on_change
+  end
+
+  ## on the fly updates of monitored files list
+
+  test "reattaches to new monitored files" do
+    @handler.listen %w( foo bar )
+    @loop.watchers.size.should be(2)
+    @loop.watchers.every.path.should include('foo')
+    @loop.watchers.every.path.should include('bar')
+
+    @handler.refresh %w( baz bax )
+    @loop.watchers.size.should be(2)
+    @loop.watchers.every.path.should include('baz')
+    @loop.watchers.every.path.should include('bax')
+    @loop.watchers.every.path.should exclude('foo')
+    @loop.watchers.every.path.should exclude('bar')
+  end
+end

data/test/test_controller.rb

@@ -0,0 +1,104 @@
+require 'test/test_helper'
+require 'observer'
+
+class MockHandler
+  include Observable
+  def listen(paths)  end
+  def refresh(paths) end
+end
+
+class TestController < Test::Unit::TestCase
+  include Watchr
+
+  def to_p(str)
+    Pathname(str).expand_path
+  end
+
+  def setup
+    @script     = Script.new
+    @handler    = MockHandler.new
+    @controller = Controller.new(@script, @handler)
+  end
+
+  test "triggers listening state on run" do
+    @controller.stubs(:monitored_paths).returns %w( foo bar )
+    @handler.expects(:listen).with %w( foo bar )
+    @controller.run
+  end
+
+  test "adds itself as handler observer" do
+    @handler.count_observers.should be(1)
+    @handler.delete_observer(@controller)
+    @handler.count_observers.should be(0)
+  end
+
+  ## monitored paths list
+
+  test "fetches monitored paths" do
+    Dir.expects(:[]).at_least_once.with('**/*').returns(%w(
+      a
+      b/x.z
+      b/c
+      b/c/y.z
+    ))
+    script = Script.new
+    script.watch('.\.z') { :x }
+
+    contrl = Controller.new(script, MockHandler.new)
+    contrl.monitored_paths.should include(to_p('b/x.z'))
+    contrl.monitored_paths.should include(to_p('b/c/y.z'))
+  end
+
+  test "doesn't fetch unmonitored paths" do
+    Dir.expects(:[]).at_least_once.with('**/*').returns(%w(
+      a
+      b/x.z
+      b/c
+      b/c/y.z
+    ))
+    script = Script.new
+    script.watch('.\.z') { :x }
+
+    contrl = Controller.new(script, MockHandler.new)
+    contrl.monitored_paths.should exclude(to_p('a'))
+    contrl.monitored_paths.should exclude(to_p('b/c'))
+    contrl.monitored_paths.should exclude(to_p('p/q.z'))
+  end
+
+  test "monitored paths include script" do
+    Dir.expects(:[]).at_least_once.with('**/*').returns(%w( a ))
+    Script.any_instance.stubs(:parse!)
+
+    path   = to_p('some/file')
+    script = Script.new(path)
+    contrl = Controller.new(script, MockHandler.new)
+    contrl.monitored_paths.should include(path)
+  end
+
+  ## on update
+
+  test "calls action for path" do
+    path = to_p('abc')
+    @script.expects(:action_for).with(path).returns(lambda {})
+
+    @controller.update('abc')
+  end
+
+  test "parses script on script file update" do
+    path = to_p('abc')
+    @script.stubs(:path).returns(path)
+    @script.expects(:parse!)
+
+    @controller.update('abc')
+  end
+
+  test "refreshes handler on script file update" do
+    path = to_p('abc')
+    @script.stubs(:path).returns(path)
+    @controller.stubs(:monitored_paths).returns %w( foo bar )
+
+    @handler.expects(:refresh).with %w( foo bar )
+    @controller.update('abc')
+  end
+end
+

data/test/test_helper.rb

@@ -6,13 +6,13 @@ require 'every'
 require 'pending'
 begin
   require 'ruby-debug'
-  require 'phocus'
   require 'redgreen'
+  require 'phocus'
 rescue LoadError, RuntimeError
 end
 
-ROOT = Pathname(__FILE__).dirname.parent
-$:.unshift(ROOT.join('lib'))
+root = Pathname(__FILE__).dirname.parent.expand_path
+$:.unshift(root.join('lib').to_s).uniq!
 
 require 'watchr'
 
@@ -23,45 +23,28 @@ class Test::Unit::TestCase
       define_method(name, &block)
     end
     alias :should :test
-  end
-end
 
-class Pathname
-  def rel
-    self.relative_path_from(ROOT).to_s
-  end
-  def pattern
-    Regexp.escape(self.rel)
-  end
-  def touch(time = Time.now)
-    `touch -mt #{time.strftime('%Y%m%d%H%M.%S')} #{self.expand_path.to_s}`
-    self
-  end
-  def mtime=(t)
-    self.touch(t).mtime
+    # noop
+    def xtest(*args) end
   end
 end
 
-class Fixture
-  DIR = Pathname(__FILE__).dirname.join('fixtures')
+# taken from minitest/unit.rb
+# (with modifications)
+def capture_io
+  require 'stringio'
 
-  class << self
-    attr_accessor :files
+  orig_stdout, orig_stderr         = $stdout, $stderr
+  captured_stdout, captured_stderr = StringIO.new, StringIO.new
+  $stdout, $stderr                 = captured_stdout, captured_stderr
 
-    def create(name=nil, content=nil)
-      name ||= 'a.rb'
-      file = DIR.join(name)
-      self.files ||= []
-      self.files << file
-      file.open('w+') {|f| f << (content || "fixture\n") }
-      file
-    end
+  yield
 
-    def delete_all
-      DIR.entries.each do |fixture|
-        next if %w( .. . ).include?(fixture.to_s)
-        DIR.join(fixture.to_s).expand_path.delete
-      end
-    end
-  end
+  return Struct.new(:stdout, :stderr).new(
+    captured_stdout.string,
+    captured_stderr.string
+  )
+ensure
+  $stdout = orig_stdout
+  $stderr = orig_stderr
 end

data/test/test_script.rb

@@ -0,0 +1,88 @@
+require 'test/test_helper'
+
+class TestScript < Test::Unit::TestCase
+  include Watchr
+
+  ## external api
+
+  test "watch" do
+    Script.new.watch('pattern')
+    Script.new.watch('pattern') { nil }
+  end
+
+  test "default action" do
+    Script.new.default_action { nil }
+  end
+
+  ## functionality
+
+  test "rule object" do
+    rule = Script.new.watch('pattern') { nil }
+    rule.pattern.should be('pattern')
+    rule.action.call.should be(nil)
+  end
+
+  test "finds action for path" do
+    script = Script.new
+    script.watch('abc') { :x }
+    script.watch('def') { :y }
+    script.action_for('abc').call.should be(:x)
+  end
+
+  test "collects patterns" do
+    script = Script.new
+    script.watch('abc')
+    script.watch('def')
+    script.patterns.should include('abc')
+    script.patterns.should include('def')
+  end
+
+  test "parses script file" do
+    file = StringIO.new(<<-STR)
+      watch( 'abc' ) { :x }
+    STR
+    script = Script.new(file)
+    script.action_for('abc').call.should be(:x)
+  end
+
+  test "actions receive a MatchData object" do
+    script = Script.new
+    script.watch('de(.)') {|m| [m[0], m[1]] }
+    script.action_for('def').call.should be(%w( def f ))
+  end
+
+  test "rule's default action" do
+    script = Script.new
+
+    script.watch('abc')
+    script.action_for('abc').call.should be(nil)
+    script.default_action { :x }
+
+    script.watch('def')
+    script.action_for('def').call.should be(:x)
+  end
+
+  test "file path" do
+    Script.any_instance.stubs(:parse!)
+    path   = Pathname('some/file').expand_path
+    script = Script.new(path)
+    script.path.should be(path)
+  end
+
+  test "later rules take precedence" do
+    script = Script.new
+
+    script.watch('a/(.*)\.x')   { :x }
+    script.watch('a/b/(.*)\.x') { :y }
+
+    script.action_for('a/b/c.x').call.should be(:y)
+  end
+
+  test "rule patterns match against paths relative to pwd" do
+    script = Script.new
+
+    script.watch('^abc') { :x }
+    path = Pathname(Dir.pwd) + 'abc'
+    script.action_for(path).call.should be(:x)
+  end
+end