watchr 0.5.6 → 0.5.7

data/.gitignore

@@ -0,0 +1,5 @@
+doc/
+pkg/
+bk/
+.wiki
+.yardoc

data/History.txt

@@ -0,0 +1,32 @@
+
+=== v0.5.7
+
+* Added manifest.watchr script
+* Unix handler supports :deleted event type
+* Unix handler supports :accessed (atime), :modified (mtime) and :changed
+  (ctime) event types (thanks gzuki[http://github.com/gzuki] for initial work)
+
+
+=== v0.5.6
+
+* Rev gem optional in development (thanks TwP[http://github.com/TwP])
+* Allow gems to bundle .watchr scripts (thanks foca[http://github.com/foca])
+
+    gemname/lib/gemname.watchr
+
+  is now automatically picked up with
+
+    $ watchr gemname.watchr
+
+* Look for script in path
+* debug msg when rev not found on *nix
+* rake task for cross interpreter testing
+
+
+=== v0.5.5
+
+* Rev gem is optional. Fixes issue #1
+  Install Rev to automatically get evented handler on *nix
+
+    gem install rev
+

data/Manifest

@@ -0,0 +1,27 @@
+.gitignore
+History.txt
+LICENSE
+Manifest
+README.rdoc
+Rakefile
+TODO.txt
+bin/watchr
+docs.watchr
+gem.watchr
+lib/watchr.rb
+lib/watchr/controller.rb
+lib/watchr/event_handlers/base.rb
+lib/watchr/event_handlers/portable.rb
+lib/watchr/event_handlers/unix.rb
+lib/watchr/script.rb
+manifest.watchr
+specs.watchr
+test/README
+test/event_handlers/test_base.rb
+test/event_handlers/test_portable.rb
+test/event_handlers/test_unix.rb
+test/test_controller.rb
+test/test_helper.rb
+test/test_script.rb
+test/test_watchr.rb
+watchr.gemspec

data/README.rdoc

@@ -99,8 +99,10 @@ docs::   http://docs.github.com/mynyml/watchr
 wiki::   http://wiki.github.com/mynyml/watchr
 bugs::   http://github.com/mynyml/watchr/issues
 
-=== Acknowledgement
+=== Contributions
+
+macournoyer[http://github.com/macournoyer]:: suggested evented backend
+foca[http://github.com/foca]:: suggested automatically picking up watchr scripts bundled in gems
+TwP[http://github.com/TwP]:: patch, Rev gem optional in development
+gzuki[http://github.com/gzuki]:: patch, recognize some event types
 
-* macournoyer[http://github.com/macournoyer] for the evented backend idea
-* foca[http://github.com/foca] for suggesting automatically picking up watchr
-  scripts bundled in gems

data/TODO.txt

@@ -4,6 +4,8 @@
 * sometimes an action is fired without a file being saved
   * buffer flushing issue?
   * libev issue?
+  * probably fixed with event type handling update, which ignores atime
+    updates by defaults
 
 * when a file is saved twice quickly, subsequent events are ignored.
   * seems like rev/libev drops the file watch

data/gem.watchr

@@ -0,0 +1,32 @@
+# Run me with:
+#
+#   $ watchr gem.watchr
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+def build(gemspec)
+  system "gem build %s" % gemspec
+  FileUtils.mv Dir['watchr-*.gem'], 'pkg/'
+  puts
+end
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch( '^watchr.gemspec$' ) { |m| build m[0] }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts " --- Building Gem ---\n\n"
+  build 'watchr.gemspec'
+end
+
+# Ctrl-C
+Signal.trap('INT') { abort("\n") }
+
+
+# vim:ft=ruby

data/lib/watchr.rb

@@ -13,6 +13,8 @@ require 'rbconfig'
 # See README for more details
 #
 module Watchr
+  VERSION = '0.5.7'
+
   begin
     require 'rev'
     HAVE_REV = true
@@ -29,8 +31,6 @@ module Watchr
     autoload :Portable, 'watchr/event_handlers/portable'
   end
 
-  VERSION = '0.5.6'
-
   class << self
     attr_accessor :options
     attr_accessor :handler

data/lib/watchr/controller.rb

@@ -48,14 +48,14 @@ module Watchr
     # path<Pathname, String>:: path that triggered event
     # event<Symbol>:: event type (ignored for now)
     #
-    def update(path, event = nil)
+    def update(path, event_type = nil)
       path = Pathname(path).expand_path
 
       if path == @script.path
         @script.parse!
         @handler.refresh(monitored_paths)
       else
-        @script.action_for(path).call
+        @script.action_for(path, event_type).call
       end
     end
 

data/lib/watchr/event_handlers/base.rb

@@ -13,13 +13,12 @@ module Watchr
       #
       # ===== Parameters
       # path<Pathname, String>:: full path or path relative to current working directory
-      # event<Symbol>:: event type (not yet used).
-      #
+      # event_type<Symbol>:: event type.
       #--
       # #changed and #notify_observers are Observable methods
-      def notify(path, event = nil)
+      def notify(path, event_type = nil)
         changed(true)
-        notify_observers(path, event)
+        notify_observers(path, event_type)
       end
 
       # Begin watching given paths and enter listening loop. Called by the controller.

data/lib/watchr/event_handlers/portable.rb

@@ -45,7 +45,7 @@ module Watchr
 
         if path.mtime > @reference_mtime
           @reference_mtime = path.mtime
-          [path, :changed]
+          [path, :modified]
         else
           nil
         end

data/lib/watchr/event_handlers/unix.rb

@@ -12,10 +12,47 @@ module Watchr
           attr_accessor :handler
         end
 
+        def initialize(path)
+          super
+          update_reference_times
+        end
+
+        # File's path as a Pathname
+        def pathname
+          @pathname ||= Pathname(@path)
+        end
+
         # Callback. Called on file change event
         # Delegates to Controller#update, passing in path and event type
         def on_change
-          self.class.handler.notify(path, :changed)
+          self.class.handler.notify(path, type)
+          update_reference_times unless type == :deleted
+        end
+
+        private
+
+        def update_reference_times
+          @reference_atime = pathname.atime
+          @reference_mtime = pathname.mtime
+          @reference_ctime = pathname.ctime
+        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
 

data/lib/watchr/script.rb

@@ -8,6 +8,7 @@ module Watchr
   #   script = Watchr::Script.new(path)
   #
   class Script
+    DEFAULT_EVENT_TYPE = :modified
 
     # Convenience type. Provides clearer and simpler access to rule properties.
     #
@@ -17,7 +18,7 @@ module Watchr
     #   rule.pattern      #=> 'lib/.*\.rb'
     #   rule.action.call  #=> 'ohaie'
     #
-    Rule = Struct.new(:pattern, :action)
+    Rule = Struct.new(:pattern, :event_type, :action)
 
     # TODO eval context
     class API #:nodoc:
@@ -69,13 +70,18 @@ module Watchr
     #
     # ===== Parameters
     # pattern<~#match>:: pattern to match targetted paths
+    # event_type<Symbol>::
+    #   Rule will only match events of this type. Accepted types are :accessed,
+    #   :modified, :changed, :delete and nil (any), where the first three
+    #   correspond to atime, mtime and ctime respectively. Defaults to
+    #   :modified.
     # action<Block>:: action to trigger
     #
     # ===== Returns
     # rule<Rule>:: rule created by the method
     #
-    def watch(pattern, &action)
-      @rules << Rule.new(pattern, action || @default_action)
+    def watch(pattern, event_type = DEFAULT_EVENT_TYPE, &action)
+      @rules << Rule.new(pattern, event_type, action || @default_action)
       @rules.last
     end
 
@@ -120,24 +126,28 @@ module Watchr
       instance_eval(@path.read)
     end
 
-    def reset
-      @default_action = lambda {}
-      @rules.clear
-    end
-
-    # Find an action corresponding to a path. The returned action is actually a
-    # wrapper around the rule's action, with the match_data prepopulated.
+    # Find an action corresponding to a path and event type. The returned
+    # action is actually a wrapper around the rule's action, with the
+    # match_data prepopulated.
+    #
+    # ===== Params
+    # path<Pathnane,String>:: Find action that correspond to this path.
+    # event_type<Symbol>:: Find action only if rule's event if of this type.
     #
     # ===== Examples
     #
     #   script.watch( 'test/test_.*\.rb' ) {|md| "ruby #{md[0]}" }
     #   script.action_for('test/test_watchr.rb').call #=> "ruby test/test_watchr.rb"
     #
-    def action_for(path)
+    def action_for(path, event_type = DEFAULT_EVENT_TYPE)
       path = rel_path(path).to_s
-      rule = rule_for(path)
-      data = path.match(rule.pattern)
-      lambda { rule.action.call(data) }
+      rule = rules_for(path).detect {|rule| rule.event_type.nil? || rule.event_type == event_type }
+      if rule
+        data = path.match(rule.pattern)
+        lambda { rule.action.call(data) }
+      else
+        lambda {}
+      end
     end
 
     # Collection of all patterns defined in script.
@@ -161,17 +171,17 @@ module Watchr
 
     private
 
-    # Rule corresponding to a given path. If more than one rule matches, then
-    # the last defined rule takes precedence.
+    # Rules corresponding to a given path, in reversed order of precedence
+    # (latest one is most inportant).
     #
     # ===== Parameters
     # path<Pathname, String>:: path to look up rule for
     #
     # ===== Returns
-    # rule<Rule>:: rule corresponding to <tt>path</tt>
+    # rules<Array(Rule)>:: rules corresponding to <tt>path</tt>
     #
-    def rule_for(path)
-      @rules.reverse.detect {|rule| path.match(rule.pattern) }
+    def rules_for(path)
+      @rules.reverse.select {|rule| path.match(rule.pattern) }
     end
 
     # Make a path relative to current working directory.
@@ -185,5 +195,11 @@ module Watchr
     def rel_path(path)
       Pathname(path).expand_path.relative_path_from(Pathname(Dir.pwd))
     end
+
+    # Reset script state
+    def reset
+      @default_action = lambda {}
+      @rules.clear
+    end
   end
 end

data/manifest.watchr

@@ -0,0 +1,70 @@
+# Run me with:
+#
+#   $ watchr manifest.watchr
+#
+# This script will remove a file from from the Manifest when it gets deleted,
+# and will rebuild the Manifest on Ctrl-\
+#
+# Mostly serves as a demo for the :delete event type (and eventually for the
+# :added event type). In reality this is much better implemented as a git
+# post-commit script.
+#
+
+require 'pathname'
+# --------------------------------------------------
+# Helpers
+# --------------------------------------------------
+module Project
+  extend self
+  def files
+    `git ls-files --full-name`.strip.split($/).sort
+  end
+end
+
+class Manifest
+  attr_accessor :path
+
+  def initialize(path)
+    @path = Pathname(path).expand_path
+    create!
+  end
+
+  def remove(path)
+    paths = @path.read.strip.split($/)
+    @path.open('w') {|f| f << (paths - [path]).join("\n") }
+  end
+
+  def add(path)
+    paths = @path.read.strip.split($/)
+    @path.open('w') {|f| f << paths.push(path).sort.join("\n") }
+  end
+
+  private
+  def create!
+    File.open(@path.to_s, 'w') {} unless @path.exist?
+  end
+end
+
+
+@manifest = Manifest.new('Manifest')
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch('.*', :deleted ) do |md|
+  @manifest.remove(md[0])
+  puts "removed #{md[0].inspect} from Manifest"
+end
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts " --- Updated Manifest ---\n"
+  @manifest.path.open('w') {|m| m << Project.files.join("\n").strip }
+end
+
+# Ctrl-C
+Signal.trap('INT') { abort("\n") }
+

data/test/README

@@ -0,0 +1,11 @@
+
+To use local watchr executable for dev work:
+
+  $ ruby -rubygems -Ilib ./bin/watchr -d specs.watchr
+
+To force a specific handler:
+
+  $ HANDLER=protable watchr -d specs.watchr
+  $ HANDLER=unix watchr -d specs.watchr
+
+  (see Watchr.handler)

data/test/event_handlers/test_portable.rb

@@ -35,7 +35,7 @@ class PortableEventHandlerTest < Test::Unit::TestCase
     @foo.stubs(:mtime).returns(Time.now + 100) # fake event
 
     @handler.listen [ @foo, @bar ]
-    @handler.expects(:notify).with(@foo, :changed)
+    @handler.expects(:notify).with(@foo, :modified)
     @handler.trigger
   end
 

data/test/event_handlers/test_unix.rb

@@ -1,6 +1,10 @@
+require 'test/test_helper'
+
 if Watchr::HAVE_REV
 
-require 'test/test_helper'
+class Watchr::EventHandler::Unix::SingleFileWatcher
+  public :type
+end
 
 class UnixEventHandlerTest < Test::Unit::TestCase
   include Watchr
@@ -8,8 +12,17 @@ class UnixEventHandlerTest < Test::Unit::TestCase
   SingleFileWatcher = EventHandler::Unix::SingleFileWatcher
 
   def setup
+    @now = Time.now
+    pathname = Pathname.new('foo/bar')
+    pathname.stubs(:atime ).returns(@now)
+    pathname.stubs(:mtime ).returns(@now)
+    pathname.stubs(:ctime ).returns(@now)
+    pathname.stubs(:exist?).returns(true)
+    SingleFileWatcher.any_instance.stubs(:pathname).returns(pathname)
+
     @loop    = Rev::Loop.default
     @handler = EventHandler::Unix.new
+    @watcher = SingleFileWatcher.new('foo/bar')
     @loop.stubs(:run)
   end
 
@@ -23,6 +36,60 @@ class UnixEventHandlerTest < Test::Unit::TestCase
     @handler.listen([])
   end
 
+  ## SingleFileWatcher
+
+  test "watcher pathname" do
+    @watcher.pathname.should be_kind_of(Pathname)
+    @watcher.pathname.to_s.should be(@watcher.path)
+  end
+
+  test "stores reference times" do
+    @watcher.pathname.stubs(:atime).returns(:time)
+    @watcher.pathname.stubs(:mtime).returns(:time)
+    @watcher.pathname.stubs(:ctime).returns(:time)
+
+    @watcher.send(:update_reference_times)
+    @watcher.instance_variable_get(:@reference_atime).should be(:time)
+    @watcher.instance_variable_get(:@reference_mtime).should be(:time)
+    @watcher.instance_variable_get(:@reference_ctime).should be(:time)
+  end
+
+  test "stores initial reference times" do
+    SingleFileWatcher.any_instance.expects(:update_reference_times)
+    SingleFileWatcher.new('foo')
+  end
+
+  test "updates reference times on change" do
+    @watcher.expects(:update_reference_times)
+    @watcher.on_change
+  end
+
+  test "detects event type" do
+    trigger_event @watcher, @now, :atime
+    @watcher.type.should be(:accessed)
+
+    trigger_event @watcher, @now, :mtime
+    @watcher.type.should be(:modified)
+
+    trigger_event @watcher, @now, :ctime
+    @watcher.type.should be(:changed)
+
+    trigger_event @watcher, @now, :atime, :mtime
+    @watcher.type.should be(:modified)
+
+    trigger_event @watcher, @now, :mtime, :ctime
+    @watcher.type.should be(:modified)
+
+    trigger_event @watcher, @now, :atime, :ctime
+    @watcher.type.should be(:accessed)
+
+    trigger_event @watcher, @now, :atime, :mtime, :ctime
+    @watcher.type.should be(:modified)
+
+    @watcher.pathname.stubs(:exist?).returns(false)
+    @watcher.type.should be(:deleted)
+  end
+
   ## monitoring file events
 
   test "listens for events on monitored files" do
@@ -33,11 +100,31 @@ class UnixEventHandlerTest < Test::Unit::TestCase
   end
 
   test "notifies observers on file event" do
-    watcher = SingleFileWatcher.new('foo/bar')
-    watcher.stubs(:path).returns('foo/bar')
+    @watcher.stubs(:path).returns('foo')
+    @handler.expects(:notify).with('foo', anything)
+    @watcher.on_change
+  end
 
+  test "notifies observers of event type" do
+    trigger_event @watcher, @now, :atime
+    @handler.expects(:notify).with('foo/bar', :accessed)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :mtime
+    @handler.expects(:notify).with('foo/bar', :modified)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :ctime
     @handler.expects(:notify).with('foo/bar', :changed)
-    watcher.on_change
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :atime, :mtime, :ctime
+    @handler.expects(:notify).with('foo/bar', :modified)
+    @watcher.on_change
+
+    @watcher.pathname.stubs(:exist?).returns(false)
+    @handler.expects(:notify).with('foo/bar', :deleted)
+    @watcher.on_change
   end
 
   ## on the fly updates of monitored files list
@@ -55,6 +142,21 @@ class UnixEventHandlerTest < Test::Unit::TestCase
     @loop.watchers.every.path.should exclude('foo')
     @loop.watchers.every.path.should exclude('bar')
   end
+
+  private
+
+  def trigger_event(watcher, now, *types)
+    watcher.pathname.stubs(:atime).returns(now)
+    watcher.pathname.stubs(:mtime).returns(now)
+    watcher.pathname.stubs(:ctime).returns(now)
+    watcher.instance_variable_set(:@reference_atime, now)
+    watcher.instance_variable_set(:@reference_mtime, now)
+    watcher.instance_variable_set(:@reference_ctime, now)
+
+    types.each do |type|
+      watcher.pathname.stubs(type).returns(now+10)
+    end
+  end
 end
 
 end  # if Watchr::HAVE_REV

data/test/test_controller.rb

@@ -78,9 +78,9 @@ class TestController < Test::Unit::TestCase
 
   test "calls action for path" do
     path = to_p('abc')
-    @script.expects(:action_for).with(path).returns(lambda {})
+    @script.expects(:action_for).with(path, :modified).returns(lambda {})
 
-    @controller.update('abc')
+    @controller.update('abc', :modified)
   end
 
   test "parses script on script file update" do
@@ -97,7 +97,7 @@ class TestController < Test::Unit::TestCase
     @controller.stubs(:monitored_paths).returns %w( foo bar )
 
     @handler.expects(:refresh).with %w( foo bar )
-    @controller.update('abc')
+    @controller.update(path)
   end
 end
 

data/test/test_script.rb

@@ -12,6 +12,7 @@ class TestScript < Test::Unit::TestCase
 
   test "watch" do
     @script.watch('pattern')
+    @script.watch('pattern', :event_type)
     @script.watch('pattern') { nil }
   end
 
@@ -22,17 +23,40 @@ class TestScript < Test::Unit::TestCase
   ## functionality
 
   test "rule object" do
-    rule = @script.watch('pattern') { nil }
+    rule = @script.watch('pattern', :modified) { nil }
     rule.pattern.should be('pattern')
+    rule.event_type.should be(:modified)
     rule.action.call.should be(nil)
   end
 
+  test "default event type" do
+    rule = @script.watch('pattern') { nil }
+    rule.event_type.should be(:modified)
+  end
+
   test "finds action for path" do
     @script.watch('abc') { :x }
     @script.watch('def') { :y }
     @script.action_for('abc').call.should be(:x)
   end
 
+  test "finds action for path with event type" do
+    @script.watch('abc', :accessed) { :x }
+    @script.watch('abc', :modified) { :y }
+    @script.action_for('abc', :accessed).call.should be(:x)
+  end
+
+  test "finds action for path with any event type" do
+    @script.watch('abc', nil) { :x }
+    @script.watch('abc', :modified) { :y }
+    @script.action_for('abc', :accessed).call.should be(:x)
+  end
+
+  test "no action for path" do
+    @script.watch('abc', :accessed) { :x }
+    @script.action_for('abc', :modified).call.should be(nil)
+  end
+
   test "collects patterns" do
     @script.watch('abc')
     @script.watch('def')
@@ -52,8 +76,7 @@ class TestScript < Test::Unit::TestCase
   test "resets state" do
     @script.default_action { 'x' }
     @script.watch('foo') { 'bar' }
-    @script.reset
-    @script.instance_variable_get(:@default_action).should be_kind_of(Proc)
+    @script.send(:reset)
     @script.instance_variable_get(:@default_action).call.should be(nil)
     @script.instance_variable_get(:@rules).should be([])
   end

data/watchr.gemspec

@@ -1,7 +1,7 @@
 
 Gem::Specification.new do |s|
   s.name              = 'watchr'
-  s.version           = '0.5.6'
+  s.version           = '0.5.7'
   s.summary           = "Modern continious testing (flexible alternative to autotest)"
   s.description       = "Modern continious testing (flexible alternative to autotest)."
   s.author            = "mynyml"
@@ -14,26 +14,32 @@ Gem::Specification.new do |s|
   s.bindir            = "bin"
   s.executables       = "watchr"
   s.files = %w[
-    README.rdoc
+    .gitignore
+    History.txt
     LICENSE
-    TODO.txt
+    Manifest
+    README.rdoc
     Rakefile
+    TODO.txt
     bin/watchr
+    docs.watchr
+    gem.watchr
     lib/watchr.rb
-    lib/watchr/script.rb
     lib/watchr/controller.rb
     lib/watchr/event_handlers/base.rb
-    lib/watchr/event_handlers/unix.rb
     lib/watchr/event_handlers/portable.rb
-    test/test_helper.rb
-    test/test_watchr.rb
-    test/test_script.rb
-    test/test_controller.rb
+    lib/watchr/event_handlers/unix.rb
+    lib/watchr/script.rb
+    manifest.watchr
+    specs.watchr
+    test/README
     test/event_handlers/test_base.rb
-    test/event_handlers/test_unix.rb
     test/event_handlers/test_portable.rb
-    specs.watchr
-    docs.watchr
+    test/event_handlers/test_unix.rb
+    test/test_controller.rb
+    test/test_helper.rb
+    test/test_script.rb
+    test/test_watchr.rb
     watchr.gemspec
   ]
   s.test_files = %w[

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: watchr
 version: !ruby/object:Gem::Version 
-  version: 0.5.6
+  version: 0.5.7
 platform: ruby
 authors: 
 - mynyml
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-29 00:00:00 -04:00
+date: 2009-10-02 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -71,26 +71,32 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
-- README.rdoc
+- .gitignore
+- History.txt
 - LICENSE
-- TODO.txt
+- Manifest
+- README.rdoc
 - Rakefile
+- TODO.txt
 - bin/watchr
+- docs.watchr
+- gem.watchr
 - lib/watchr.rb
-- lib/watchr/script.rb
 - lib/watchr/controller.rb
 - lib/watchr/event_handlers/base.rb
-- lib/watchr/event_handlers/unix.rb
 - lib/watchr/event_handlers/portable.rb
-- test/test_helper.rb
-- test/test_watchr.rb
-- test/test_script.rb
-- test/test_controller.rb
+- lib/watchr/event_handlers/unix.rb
+- lib/watchr/script.rb
+- manifest.watchr
+- specs.watchr
+- test/README
 - test/event_handlers/test_base.rb
-- test/event_handlers/test_unix.rb
 - test/event_handlers/test_portable.rb
-- specs.watchr
-- docs.watchr
+- test/event_handlers/test_unix.rb
+- test/test_controller.rb
+- test/test_helper.rb
+- test/test_script.rb
+- test/test_watchr.rb
 - watchr.gemspec
 has_rdoc: true
 homepage: http://mynyml.com/ruby/flexible-continuous-testing