tekkub-watchr 0.5.0

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

@@ -0,0 +1,50 @@
+require 'pathname'
+require 'test/unit'
+require 'matchy'
+require 'mocha'
+require 'every'
+require 'pending'
+begin
+  require 'ruby-debug'
+  require 'redgreen'
+  require 'phocus'
+rescue LoadError, RuntimeError
+end
+
+root = Pathname(__FILE__).dirname.parent.expand_path
+$:.unshift(root.join('lib').to_s).uniq!
+
+require 'watchr'
+
+class Test::Unit::TestCase
+  class << self
+    def test(name, &block)
+      name = :"test_#{name.gsub(/\s/,'_')}"
+      define_method(name, &block)
+    end
+    alias :should :test
+
+    # noop
+    def xtest(*args) end
+  end
+end
+
+# taken from minitest/unit.rb
+# (with modifications)
+def capture_io
+  require 'stringio'
+
+  orig_stdout, orig_stderr         = $stdout, $stderr
+  captured_stdout, captured_stderr = StringIO.new, StringIO.new
+  $stdout, $stderr                 = captured_stdout, captured_stderr
+
+  yield
+
+  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

data/test/test_watchr.rb

@@ -0,0 +1,59 @@
+require 'test/test_helper'
+
+class TestWatchr < Test::Unit::TestCase
+
+  def setup
+    Watchr.options = nil
+  end
+
+  ## options
+
+  test "debug option" do
+    Watchr.options.debug.should be(false)
+    Watchr.options.debug = true
+    Watchr.options.debug.should be(true)
+  end
+
+  ## functionality
+
+  test "debug" do
+    capture_io { Watchr.debug('abc') }.stdout.should be('')
+    Watchr.options.debug = true
+    capture_io { Watchr.debug('abc') }.stdout.should be("[watchr debug] abc\n")
+  end
+
+  test "picking handler" do
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'linux'
+    Watchr.handler.should be(Watchr::EventHandler::Unix)
+
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'bsd'
+    Watchr.handler.should be(Watchr::EventHandler::Unix)
+
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'darwin'
+    Watchr.handler.should be(Watchr::EventHandler::Unix)
+
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'unix'
+    Watchr.handler.should be(Watchr::EventHandler::Unix)
+
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'mswin'
+    Watchr.handler.should be(Watchr::EventHandler::Portable)
+
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'cygwin'
+    Watchr.handler.should be(Watchr::EventHandler::Portable)
+
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'portable'
+    Watchr.handler.should be(Watchr::EventHandler::Portable)
+
+    Watchr.handler = nil
+    ENV['HANDLER'] = 'other'
+    Watchr.handler.should be(Watchr::EventHandler::Portable)
+  end
+end
+

data/watchr.gemspec

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: watchr
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Martin Aumont
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-12 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rev
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+description: Continious anything; project files observer/trigger.
+email: mynyml@gmail.com
+executables: 
+- watchr
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- test
+- test/event_handlers
+- test/event_handlers/test_portable.rb
+- test/event_handlers/test_base.rb
+- test/event_handlers/test_unix.rb
+- test/test_controller.rb
+- test/test_watchr.rb
+- test/test_helper.rb
+- test/test_script.rb
+- TODO.txt
+- bin
+- bin/watchr
+- lib
+- lib/watchr
+- lib/watchr/version.rb
+- lib/watchr/event_handlers
+- lib/watchr/event_handlers/portable.rb
+- lib/watchr/event_handlers/base.rb
+- lib/watchr/event_handlers/unix.rb
+- lib/watchr/script.rb
+- lib/watchr/controller.rb
+- lib/watchr.rb
+- README.rdoc
+- LICENSE
+- docs.watchr
+- specs.watchr
+- watchr.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Continious anything
+test_files: []
+