observr 1.0

data/lib/observr/script.rb

@@ -0,0 +1,257 @@
+module Observr
+
+  # A script object wraps a script file, and is used by a controller.
+  #
+  # @example
+  #
+  #     path   = Pathname.new('specs.observr')
+  #     script = Observr::Script.new(path)
+  #
+  class Script
+
+    # @private
+    DEFAULT_EVENT_TYPE = :modified
+
+    # Convenience type. Provides clearer and simpler access to rule properties.
+    #
+    # @example
+    #
+    #     rule = script.watch('lib/.*\.rb') { 'ohaie' }
+    #     rule.pattern      #=> 'lib/.*\.rb'
+    #     rule.action.call  #=> 'ohaie'
+    #
+    Rule = Struct.new(:pattern, :event_type, :action)
+
+    # Script file evaluation context
+    #
+    # Script files are evaluated in the context of an instance of this class so
+    # that they get a clearly defined set of methods to work with. In other
+    # words, it is the user script's API.
+    #
+    # @private
+    class EvalContext #:nodoc:
+
+      def initialize(script)
+        @__script = script
+      end
+
+      # Delegated to script
+      def default_action(&action)
+        @__script.default_action(&action)
+      end
+
+      # Delegated to script
+      def watch(*args, &block)
+        @__script.watch(*args, &block)
+      end
+
+      # Reload script
+      def reload
+        @__script.parse!
+      end
+    end
+
+    # EvalContext instance
+    #
+    # @example
+    #
+    #     script.ec.watch('pattern') { }
+    #     script.ec.reload
+    #
+    # @return [EvalContext]
+    #
+    attr_reader :ec
+
+    # Defined rules
+    #
+    # @return [Rule]
+    #   all rules defined with `#watch` calls
+    #
+    attr_reader :rules
+
+    # Create a Script object for script at `path`
+    #
+    # @param [Pathname] path
+    #   the path to the script
+    #
+    def initialize(path = nil)
+      @path = path
+      @rules = []
+      @default_action = Proc.new {}
+      @ec = EvalContext.new(self)
+    end
+
+    # Main script API method. Builds a new rule, binding a pattern to an action.
+    #
+    # Whenever a file is saved that matches a rule's `pattern`, its
+    # corresponding `action` is triggered.
+    #
+    # Patterns can be either a Regexp or a string. Because they always
+    # represent paths however, it's simpler to use strings. But remember to use
+    # single quotes (not double quotes), otherwise escape sequences will be
+    # parsed (for example `"foo/bar\.rb" #=> "foo/bar.rb"`, notice "\." becomes
+    # "."), and won't be interpreted as the regexp you expect.
+    #
+    # Also note that patterns will be matched against relative paths (relative
+    # to current working directory).
+    #
+    # Actions, the blocks passed to `watch`, receive a `MatchData` object as
+    # argument. It will be populated with the whole matched string ( `md[0]` )
+    # as well as individual backreferences ( `md[1..n]` ). See `MatchData#[]`
+    # documentation for more details.
+    #
+    # @example
+    #
+    #     # in script file
+    #     watch( 'test/test_.*\.rb' )  {|md| system("ruby #{md[0]}") }
+    #     watch( 'lib/(.*)\.rb' )      {|md| system("ruby test/test_#{md[1]}.rb") }
+    #
+    # With these two rules, observr will run any test file whenever it is itself
+    # changed (first rule), and will also run a corresponding test file
+    # whenever a lib file is changed (second rule).
+    #
+    # @param [#match] pattern
+    #   pattern to match targetted paths
+    #
+    # @param [Symbol] event_type
+    #   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`.
+    #
+    # @yield
+    #   action to trigger
+    #
+    # @return [Rule]
+    #
+    def watch(pattern, event_type = DEFAULT_EVENT_TYPE, &action)
+      @rules << Rule.new(pattern, event_type, action || @default_action)
+      @rules.last
+    end
+
+    # Convenience method. Define a default action to be triggered when a rule
+    # has none specified. When called without a block, acts as a getter and
+    # returns stored default_action
+    #
+    # @example
+    #
+    #     # in script file
+    #
+    #     default_action { system('rake --silent yard') }
+    #
+    #     watch( 'lib/.*\.rb'  )
+    #     watch( 'README.md'   )
+    #     watch( 'TODO.txt'    )
+    #     watch( 'LICENSE'     )
+    #
+    #     # is equivalent to:
+    #
+    #     watch( 'lib/.*\.rb'  ) { system('rake --silent yard') }
+    #     watch( 'README.md'   ) { system('rake --silent yard') }
+    #     watch( 'TODO.txt'    ) { system('rake --silent yard') }
+    #     watch( 'LICENSE'     ) { system('rake --silent yard') }
+    #
+    # @return [Proc]
+    #   default action
+    #
+    def default_action(&action)
+      @default_action = action if action
+      @default_action
+    end
+
+    # Reset script state
+    def reset
+      @rules = []
+      @default_action = Proc.new {}
+    end
+
+    # Eval content of script file.
+    #
+    # @todo improve ENOENT error handling
+    def parse!
+      return unless @path
+      reset
+      @ec.instance_eval(@path.read, @path.to_s)
+    rescue Errno::ENOENT
+      sleep(0.3) #enough?
+      retry
+    ensure
+      Observr.debug('loaded script file %s' % @path.to_s.inspect)
+    end
+
+    # 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.
+    #
+    # @example
+    #
+    #     script.watch( 'test/test_.*\.rb' ) {|md| "ruby #{md[0]}" }
+    #     script.action_for('test/test_observr.rb').call #=> "ruby test/test_observr.rb"
+    #
+    # @param [Pathname, String] path
+    #   find action that corresponds to this path.
+    #
+    # @param [Symbol] event_type
+    #   find action only if rule's event is of this type.
+    #
+    # @return [Proc]
+    #   action, preparsed and ready to be called
+    #
+    def action_for(path, event_type = DEFAULT_EVENT_TYPE)
+      path = rel_path(path).to_s
+      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.
+    #
+    # @return [Array<String,Regexp>]
+    #   all defined patterns
+    #
+    def patterns
+      #@rules.every.pattern
+      @rules.map {|r| r.pattern }
+    end
+
+    # Path to the script file corresponding to this object
+    #
+    # @return [Pathname]
+    #   absolute path to script file
+    #
+    def path
+      @path && Pathname(@path.respond_to?(:to_path) ? @path.to_path : @path.to_s).expand_path
+    end
+
+    private
+
+    # Rules corresponding to a given path, in reversed order of precedence
+    # (latest one is most inportant).
+    #
+    # @param [Pathname, String] path
+    #   path to look up rule for
+    #
+    # @return [Array<Rule>]
+    #   rules corresponding to `path`
+    #
+    def rules_for(path)
+      @rules.reverse.select {|rule| path.match(rule.pattern) }
+    end
+
+    # Make a path relative to current working directory.
+    #
+    # @param [Pathname, String] path
+    #   absolute or relative path
+    #
+    # @return [Pathname]
+    #   relative path, from current working directory.
+    #
+    def rel_path(path)
+      Pathname(path).expand_path.relative_path_from(Pathname(Dir.pwd))
+    end
+  end
+end

data/observr.gemspec

@@ -0,0 +1,21 @@
+require './lib/observr'
+
+Gem::Specification.new do |s|
+  s.name                = "observr"
+  s.summary             = "Modern continuous testing (flexible alternative to autotest)"
+  s.description         = "Modern continuous testing (flexible alternative to autotest)."
+  s.author              = "mynyml"
+  s.email               = "mynyml@gmail.com"
+  s.homepage            = "http://mynyml.com/ruby/flexible-continuous-testing"
+  s.rubyforge_project   = "observr"
+  s.require_path        = "lib"
+  s.bindir              = "bin"
+  s.license             = "MIT"
+  s.executables         = "observr"
+  s.version             =  Observr::VERSION
+  s.files               =  `git ls-files`.strip.split("\n")
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'every'
+end

data/specs.watchr

@@ -0,0 +1,37 @@
+# Run me with:
+#   $ observr specs.observr
+
+# --------------------------------------------------
+# Rules
+# --------------------------------------------------
+watch( '^test.*/test_.*\.rb'                 )  { |m| ruby  m[0] }
+watch( '^lib/(.*)\.rb'                       )  { |m| ruby "test/test_#{m[1]}.rb" }
+watch( '^lib/observr/(.*)\.rb'                )  { |m| ruby "test/test_#{m[1]}.rb" }
+watch( '^lib/observr/event_handlers/(.*)\.rb' )  { |m| ruby "test/event_handlers/test_#{m[1]}.rb" }
+watch( '^test/test_helper\.rb'               )  { ruby tests }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+Signal.trap('QUIT') { ruby tests  } # Ctrl-\
+Signal.trap('INT' ) { abort("\n") } # Ctrl-C
+
+# --------------------------------------------------
+# Helpers
+# --------------------------------------------------
+def ruby(*paths)
+  run "ruby #{gem_opt} -I.:lib:test -e'%w( #{paths.flatten.join(' ')} ).each {|p| require p }'"
+end
+
+def tests
+  Dir['test/**/test_*.rb'] - ['test/test_helper.rb']
+end
+
+def run( cmd )
+  puts   cmd
+  system cmd
+end
+
+def gem_opt
+  defined?(Gem) ? "-rubygems" : ""
+end

data/test/README

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

data/test/event_handlers/test_base.rb

@@ -0,0 +1,24 @@
+require 'test/test_helper'
+
+class BaseEventHandlerTest < MiniTest::Unit::TestCase
+
+  class Handler
+    include Observr::EventHandler::Base
+  end
+
+  def setup
+    @handler = Handler.new
+  end
+
+  test "api" do
+    assert_respond_to @handler, :notify
+    assert_respond_to @handler, :listen
+    assert_respond_to @handler, :refresh
+    assert_includes   @handler.class.ancestors, 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_darwin.rb

@@ -0,0 +1,111 @@
+require 'test/test_helper'
+
+if Observr::HAVE_FSE
+
+class Observr::EventHandler::Darwin
+  attr_accessor :paths
+
+  def start()   end #noop
+  def restart() end #noop
+
+  public :on_change, :registered_directories
+end
+
+class DarwinEventHandlerTest < MiniTest::Unit::TestCase
+  include Observr
+
+  def tempfile(name)
+    file = Tempfile.new(name, @root.to_s)
+    Pathname(file.path)
+  ensure
+    file.close
+  end
+
+  def setup
+    @root = Pathname(Dir.mktmpdir("WATCHR_SPECS-"))
+
+    @now = Time.now
+    @handler = EventHandler::Darwin.new
+
+    @foo = tempfile('foo').expand_path
+    @bar = tempfile('bar').expand_path
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@root.to_s)
+  end
+
+  test "listening triggers listening state" do
+    @handler.expects(:start)
+    @handler.listen([])
+  end
+
+  test "listens for events on monitored files" do
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.paths, @foo
+    assert_includes @handler.paths, @bar
+  end
+
+  test "reattaches to new monitored files" do
+    @baz = tempfile('baz').expand_path
+    @bax = tempfile('bax').expand_path
+
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.paths, @foo
+    assert_includes @handler.paths, @bar
+
+    @handler.refresh [ @baz, @bax ]
+    assert_includes @handler.paths, @baz
+    assert_includes @handler.paths, @bax
+    refute_includes @handler.paths, @foo
+    refute_includes @handler.paths, @bar
+  end
+
+  ## event types
+
+  test "deleted file event" do
+    @foo.stubs(:exist?).returns(false)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :deleted)
+    @handler.on_change [@root]
+  end
+
+  test "modified file event" do
+    @foo.stubs(:mtime).returns(@now + 100)
+    @handler.expects(:notify).with(@foo, :modified)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.on_change [@root]
+  end
+
+  test "accessed file event" do
+    @foo.stubs(:atime).returns(@now + 100)
+    @handler.expects(:notify).with(@foo, :accessed)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.on_change [@root]
+  end
+
+  test "changed file event" do
+    @foo.stubs(:ctime).returns(@now + 100)
+    @handler.expects(:notify).with(@foo, :changed)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.on_change [@root]
+  end
+
+  ## internal
+
+  test "registers directories" do
+    @handler.listen [ @foo, @bar ]
+
+    assert_equal @foo.dirname, @bar.dirname # make sure all tempfiles are in same dir
+    assert_equal 1, @handler.registered_directories.size
+    assert_includes @handler.registered_directories, @foo.dirname.to_s
+    assert_includes @handler.registered_directories, @bar.dirname.to_s
+  end
+end
+
+end  # if Observr::HAVE_FSE
+