nestor 0.1.0

data/vendor/watchr-0.5.7/lib/watchr/script.rb

@@ -0,0 +1,203 @@
+module Watchr
+
+  # A script object wraps a script file, and is used by a controller.
+  #
+  # ===== Examples
+  #
+  #   path   = Pathname.new('specs.watchr')
+  #   script = Watchr::Script.new(path)
+  #
+  class Script
+    DEFAULT_EVENT_TYPE = :modified
+
+    # Convenience type. Provides clearer and simpler access to rule properties.
+    #
+    # ===== Examples
+    #
+    #   rule = script.watch('lib/.*\.rb') { 'ohaie' }
+    #   rule.pattern      #=> 'lib/.*\.rb'
+    #   rule.action.call  #=> 'ohaie'
+    #
+    Rule = Struct.new(:pattern, :event_type, :action)
+
+    # TODO eval context
+    class API #:nodoc:
+    end
+
+    # Creates a script object for <tt>path</tt>.
+    #
+    # Does not parse the script.  The controller knows when to parse the script.
+    #
+    # ===== Parameters
+    # path<Pathname>:: the path to the script
+    #
+    def initialize(path)
+      @path  = path
+      @rules = []
+      @default_action = lambda {}
+    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 <tt>pattern</tt>, its
+    # corresponding <tt>action</tt> 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
+    # from current working directory).
+    #
+    # Actions, the blocks passed to <tt>watch</tt>, 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.
+    #
+    # ===== Examples
+    #
+    #   # 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, watchr 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).
+    #
+    # ===== 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, 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.
+    #
+    # ===== Examples
+    #
+    #   # in script file
+    #
+    #   default_action { system('rake --silent rdoc') }
+    #
+    #   watch( 'lib/.*\.rb'  )
+    #   watch( 'README.rdoc' )
+    #   watch( 'TODO.txt'    )
+    #   watch( 'LICENSE'     )
+    #
+    #   # equivalent to:
+    #
+    #   watch( 'lib/.*\.rb'  ) { system('rake --silent rdoc') }
+    #   watch( 'README.rdoc' ) { system('rake --silent rdoc') }
+    #   watch( 'TODO.txt'    ) { system('rake --silent rdoc') }
+    #   watch( 'LICENSE'     ) { system('rake --silent rdoc') }
+    #
+    def default_action(&action)
+      @default_action = action
+    end
+
+    # Eval content of script file.
+    #--
+    # TODO fix script file not found error
+    def parse!
+      Watchr.debug('loading script file %s' % @path.to_s.inspect)
+
+      reset
+      instance_eval(@path.read)
+
+    rescue Errno::ENOENT
+      # TODO figure out why this is happening. still can't reproduce
+      Watchr.debug('script file "not found". wth')
+      sleep(0.3) #enough?
+      instance_eval(@path.read)
+    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.
+    #
+    # ===== 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, 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.
+    #
+    # ===== Returns
+    # patterns<String, Regexp>:: all patterns
+    #
+    def patterns
+      #@rules.every.pattern
+      @rules.map {|r| r.pattern }
+    end
+
+    # Path to the script file
+    #
+    # ===== Returns
+    # path<Pathname>:: path to script file
+    #
+    def 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).
+    #
+    # ===== Parameters
+    # path<Pathname, String>:: path to look up rule for
+    #
+    # ===== Returns
+    # rules<Array(Rule)>:: rules corresponding to <tt>path</tt>
+    #
+    def rules_for(path)
+      @rules.reverse.select {|rule| path.match(rule.pattern) }
+    end
+
+    # Make a path relative to current working directory.
+    #
+    # ===== Parameters
+    # path<Pathname, String>:: absolute or relative path
+    #
+    # ===== Returns
+    # path<Pathname>:: relative path, from current working directory.
+    #
+    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/vendor/watchr-0.5.7/lib/watchr.rb

@@ -0,0 +1,113 @@
+require 'pathname'
+require 'rbconfig'
+
+# Agile development tool that monitors a directory recursively, and triggers a
+# user defined action whenever an observed file is modified. Its most typical
+# use is continuous testing.
+#
+# Usage:
+#
+#   # on command line, from project's root dir
+#   $ watchr path/to/script
+#
+# See README for more details
+#
+module Watchr
+  VERSION = '0.5.7'
+
+  begin
+    require 'rev'
+    HAVE_REV = true
+  rescue LoadError, RuntimeError
+    HAVE_REV = false
+  end
+
+  autoload :Script,     'watchr/script'
+  autoload :Controller, 'watchr/controller'
+
+  module EventHandler
+    autoload :Base,     'watchr/event_handlers/base'
+    autoload :Unix,     'watchr/event_handlers/unix' if ::Watchr::HAVE_REV
+    autoload :Portable, 'watchr/event_handlers/portable'
+  end
+
+  class << self
+    attr_accessor :options
+    attr_accessor :handler
+
+    # backwards compatibility
+    def version #:nodoc:
+      Watchr::VERSION
+    end
+
+    # Options proxy.
+    #
+    # Currently supported options:
+    # * debug<Boolean> Debugging state. More verbose.
+    #
+    # ===== Examples
+    #
+    #   Watchr.options.debug #=> false
+    #   Watchr.options.debug = true
+    #
+    # ===== Returns
+    # options<Struct>:: options proxy.
+    #
+    #--
+    # On first use, initialize the options struct and default option values.
+    def options
+      @options ||= Struct.new(:debug).new
+      @options.debug ||= false
+      @options
+    end
+
+    # Outputs formatted debug statement to stdout, only if ::options.debug is true
+    #
+    # ===== Examples
+    #
+    #   Watchr.options.debug = true
+    #   Watchr.debug('im in ur codes, notifayinin u')
+    #
+    # outputs: "[watchr debug] im in ur codes, notifayinin u"
+    #
+    def debug(str)
+      puts "[watchr debug] #{str}" if options.debug
+    end
+
+    # Detect current OS and return appropriate handler.
+    #
+    # ===== Examples
+    #
+    #   Config::CONFIG['host_os'] #=> 'linux-gnu'
+    #   Watchr.handler #=> Watchr::EventHandler::Unix
+    #
+    #   Config::CONFIG['host_os'] #=> 'cygwin'
+    #   Watchr.handler #=> Watchr::EventHandler::Portable
+    #
+    #   ENV['HANDLER'] #=> 'unix'
+    #   Watchr.handler #=> Watchr::EventHandler::Unix
+    #
+    #   ENV['HANDLER'] #=> 'portable'
+    #   Watchr.handler #=> Watchr::EventHandler::Portable
+    #
+    # ===== Returns
+    # handler<Class>:: handler class for current architecture
+    #
+    def handler
+      @handler ||=
+        case ENV['HANDLER'] || Config::CONFIG['host_os']
+          when /mswin|windows|cygwin/i
+            Watchr::EventHandler::Portable
+          when /sunos|solaris|darwin|mach|osx|bsd|linux/i, 'unix'
+            if ::Watchr::HAVE_REV
+              Watchr::EventHandler::Unix
+            else
+              Watchr.debug "rev not found. `gem install rev` to get evented handler"
+              Watchr::EventHandler::Portable
+            end
+          else
+            Watchr::EventHandler::Portable
+        end
+    end
+  end
+end

data/vendor/watchr-0.5.7/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/vendor/watchr-0.5.7/specs.watchr

@@ -0,0 +1,38 @@
+# Run me with:
+#
+#   $ watchr specs.watchr
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+def run(cmd)
+  puts(cmd)
+  system(cmd)
+end
+
+def run_all_tests
+  # see Rakefile for the definition of the test:all task
+  system( "rake -s test:all VERBOSE=true" )
+end
+
+# --------------------------------------------------
+# 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-C
+Signal.trap('INT') { abort("\n") }
+

data/vendor/watchr-0.5.7/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/vendor/watchr-0.5.7/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/vendor/watchr-0.5.7/test/event_handlers/test_portable.rb

@@ -0,0 +1,58 @@
+require 'test/test_helper'
+
+class PortableEventHandlerTest < 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, :modified)
+    @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/vendor/watchr-0.5.7/test/event_handlers/test_unix.rb

@@ -0,0 +1,162 @@
+require 'test/test_helper'
+
+if Watchr::HAVE_REV
+
+class Watchr::EventHandler::Unix::SingleFileWatcher
+  public :type
+end
+
+class UnixEventHandlerTest < Test::Unit::TestCase
+  include Watchr
+
+  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
+
+  def teardown
+    SingleFileWatcher.handler = nil
+    Rev::Loop.default.watchers.every.detach
+  end
+
+  test "triggers listening state" do
+    @loop.expects(:run)
+    @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
+    @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.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
+
+    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
+
+  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
+
+  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