nestor 0.1.0

data/vendor/watchr-0.5.7/README.rdoc

@@ -0,0 +1,108 @@
+=== Summary
+
+Agile development tool that monitors a directory tree, and triggers a user
+defined action whenever an observed file is modified. Its most typical use is
+continuous testing, and as such it is a more flexible alternative to autotest.
+
+
+=== Features
+
+watchr is:
+
+* Simple to use
+* Highly flexible
+* Evented               ( Listens for filesystem events with native c libs )
+* Portable              ( Linux, *BSD, OSX, Solaris, Windows )
+* Fast                  ( Immediately reacts to file changes )
+
+Most importantly it allows running tests in an environment that is *agnostic* to:
+
+* Web frameworks        ( rails, merb, sinatra, camping, invisible, ... )
+* Test frameworks       ( test/unit, minitest, rspec, test/spec, expectations, ... )
+* Ruby interpreters     ( ruby1.8, ruby1.9, MRI, JRuby, Rubinius, ... )
+* Package frameworks    ( rubygems, rip, ... )
+
+
+=== Usage
+
+On the command line,
+
+  $ watchr path/to/script.file
+
+will monitor files in the current directory tree, and react to events on those
+files in accordance with the script.
+
+
+=== Scripts
+
+The script contains a set of simple rules that map observed files to an action.
+Its DSL is a single method: watch(pattern, &action)
+
+  watch( 'a regexp pattern matching paths to observe' )  {|match_data_object| command_to_run }
+
+So for example,
+
+  watch( 'test/test_.*\.rb' )  {|md| system("ruby #{md[0]}") }
+
+will match any test file and run it whenever it is saved.
+
+A continuous testing script for a basic project could be
+
+  watch( 'test/test_.*\.rb' )  {|md| system("ruby #{md[0]}") }
+  watch( 'lib/(.*)\.rb' )      {|md| system("ruby test/test_#{md[1]}.rb") }
+
+which, in addition to running any saved test file as above, will also run a
+lib file's associated test. This mimics the equivalent autotest behaviour.
+
+It's easy to see why watchr is so flexible, since the whole command is custom.
+The above actions could just as easily call "jruby", "ruby --rubygems", "ruby
+-Ilib", "specrb", "rbx", ... or any combination of these. For the sake of
+comparison, autotest runs with:
+
+  /usr/bin/ruby1.8 -I.:lib:test -rubygems -e "%w[test/unit test/test_helper.rb test/test_watchr.rb].each { |f| require f }"
+
+locking the environment into ruby1.8, rubygems and test/unit for all tests.
+
+And remember the scripts are pure ruby, so feel free to add methods,
+Signal#trap calls, etc. Updates to script files are picked up on the fly (no
+need to restart watchr) so experimenting is painless.
+
+The wiki[http://wiki.github.com/mynyml/watchr] has more details and examples.
+You might also want to take a look at watchr's own scripts,
+specs.watchr[http://github.com/mynyml/watchr/blob/master/specs.watchr],
+docs.watchr[http://github.com/mynyml/watchr/blob/master/docs.watchr] and
+gem.watchr[http://github.com/mynyml/watchr/blob/master/gem.watchr], to get you
+started.
+
+
+=== Install
+
+  gem install watchr --source http://gemcutter.org
+
+If you're on *nix and have the rev[http://github.com/tarcieri/rev/] gem
+installed, Watchr will detect it and use it automatically. This will make
+Watchr evented.
+
+  gem install rev
+
+
+=== See Also
+
+redgreen[http://github.com/mynyml/redgreen]:: Standalone redgreen eye candy for test results, ala autotest.
+phocus[http://github.com/mynyml/phocus]::     Run focused tests when running the whole file/suite is unnecessary.
+
+
+=== Links
+
+source:: http://github.com/mynyml/watchr
+docs::   http://docs.github.com/mynyml/watchr
+wiki::   http://wiki.github.com/mynyml/watchr
+bugs::   http://github.com/mynyml/watchr/issues
+
+=== 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
+

data/vendor/watchr-0.5.7/Rakefile

@@ -0,0 +1,49 @@
+require 'rake/rdoctask'
+begin
+  require 'yard'
+rescue LoadError, RuntimeError
+end
+
+desc "Generate rdoc documentation."
+Rake::RDocTask.new(:rdoc => 'rdoc', :clobber_rdoc => 'rdoc:clean', :rerdoc => 'rdoc:force') { |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.title    = "Watchr"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('TODO.txt')
+  rdoc.rdoc_files.include('LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+}
+
+if defined? YARD
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = %w( lib/**/*.rb )
+    t.options = %w( -o doc/yard --readme README.rdoc --files LICENSE,TODO.txt )
+  end
+end
+
+namespace(:test) do
+
+  desc "Run all tests"
+  task(:all) do
+    tests = Dir['test/**/test_*.rb'] - ['test/test_helper.rb']
+    cmd = "ruby -rubygems -Ilib -e'%w( #{tests.join(' ')} ).each {|file| require file }'"
+    puts cmd if ENV['VERBOSE']
+    system cmd
+  end
+
+  desc "Run all tests on multiple ruby versions (requires rvm with 1.8.6 and 1.8.7)"
+  task(:portability) do
+    versions = %w( 1.8.6  1.8.7 )
+    versions.each do |version|
+      system <<-BASH
+        bash -c 'source ~/.rvm/scripts/rvm;
+                 rvm use #{version};
+                 echo "--------- `ruby -v` ----------\n";
+                 rake -s test:all'
+      BASH
+    end
+  end
+end

data/vendor/watchr-0.5.7/TODO.txt

@@ -0,0 +1,40 @@
+
+* 1.9 compatibility
+
+* 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
+
+* test on other platforms
+  x mswin
+  x cygwin
+  * bsd
+  * osx
+  * solaris
+
+* write a few prepackaged scripts
+  * post on gists
+  * post links on wiki
+  * post main links in readme
+
+* eval script within own context?
+  * use case: using <tt>path</tt> within script accesses Script#path
+
+* respond to different file events?
+  * modified
+  * created
+  * deleted
+  * etc.
+  * watch(pattern, EVENT, &action)
+  * use case: a script updates a manifest file when a file is deleted
+
+* memory profiling / benchmarks
+
+* version.watchr
+  * sync versions (gemspec & Watchr::VERSION)
+

data/vendor/watchr-0.5.7/bin/watchr

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require 'optparse'
+
+require 'watchr'
+
+module Watchr
+  # Namespaced to avoid defining global methods
+  module Bin #:nodoc:
+    extend self
+
+    def usage
+      "Usage: watchr [opts] path/to/script"
+    end
+
+    def version
+      "watchr version: %s" % Watchr::VERSION
+    end
+
+    # Find a partial path name in load path
+    #
+    # ===== Params
+    # path<Pathname>:: partial pathname
+    #
+    # ===== Returns
+    # <Pathname>::
+    #   absolute path of first occurence of partial path in load path, or nil if not found
+    #
+    def find_in_load_path(path)
+      dir = potentially_with_gem( path.basename('.watchr') ) do
+        $LOAD_PATH.detect {|p| Pathname(p).join(path).exist? }
+      end
+      dir ? path.expand_path(dir) : nil
+    end
+
+    private
+
+    # If the block returns nil, requires gem <tt>name</tt> and tries running the
+    # block again. If all fails, returns nil
+    #
+    # ===== Params
+    # name<Pathname,String>:: name of gem to require
+    #
+    # ===== Returns
+    # block's value or nil if gem <tt>name</tt> doesn't exist
+    #
+    def potentially_with_gem(name)
+      yield || (require(name) && yield)
+    rescue LoadError
+      nil
+    end
+  end
+end
+
+opts = OptionParser.new do |opts|
+  opts.banner = Watchr::Bin.usage
+
+  opts.on('-d', '--debug', "Print extra debug info while program runs") {
+    Watchr.options.debug = true
+    begin
+      require 'ruby-debug'
+    rescue LoadError, RuntimeError
+    end
+  }
+
+  opts.on_tail('-h', '--help', "Print inline help") { puts opts; exit }
+  opts.on_tail('-v', '--version', "Print version" ) { puts Watchr::Bin.version; exit }
+
+  opts.parse! ARGV
+end
+
+relative_path = Pathname( ARGV.first )                   rescue abort(Watchr::Bin.usage)
+absolute_path = Watchr::Bin.find_in_load_path(relative_path) or abort("no script found; file #{relative_path.to_s.inspect} is not in path.")
+
+Watchr::Controller.new(Watchr::Script.new(absolute_path), Watchr.handler.new).run
+

data/vendor/watchr-0.5.7/docs.watchr

@@ -0,0 +1,26 @@
+# Run me with:
+#
+#   $ watchr docs.watchr
+
+def run_rdoc
+  system('rake --silent rdoc')
+end
+
+def run_yard
+  print "\nUpdating yardocs... "
+  system('rake --silent yardoc')
+  print "done.\n"
+end
+
+def document
+  run_rdoc
+  run_yard
+end
+
+watch( 'lib/.*\.rb'  ) { document }
+watch( 'README.rdoc' ) { document }
+watch( 'TODO.txt'    ) { document }
+watch( 'LICENSE'     ) { document }
+
+
+# vim:ft=ruby

data/vendor/watchr-0.5.7/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/vendor/watchr-0.5.7/lib/watchr/controller.rb

@@ -0,0 +1,81 @@
+module Watchr
+
+  # The controller contains the app's core logic.
+  #
+  # ===== Examples
+  #
+  #   script = Watchr::Script.new(file)
+  #   contrl = Watchr::Controller.new(script)
+  #   contrl.run
+  #
+  # Calling <tt>#run</tt> will enter the listening loop, and from then on every
+  # file event will trigger its corresponding action defined in <tt>script</tt>
+  #
+  # The controller also automatically adds the script's file itself to its list
+  # of monitored files and will detect any changes to it, providing on the fly
+  # updates of defined rules.
+  #
+  class Controller
+
+    # Creates a controller object around given <tt>script</tt>
+    #
+    # ===== Parameters
+    # script<Script>:: The script object
+    #
+    def initialize(script, handler)
+      @script  = script
+      @handler = handler
+
+      @handler.add_observer(self)
+
+      Watchr.debug "using %s handler" % handler.class.name
+    end
+
+    # Enters listening loop.
+    #
+    # Will block control flow until application is explicitly stopped/killed.
+    #
+    def run
+      @script.parse!
+      @handler.listen(monitored_paths)
+    end
+
+    # Callback for file events.
+    #
+    # Called while control flow in in listening loop. It will execute the
+    # file's corresponding action as defined in the script. If the file is the
+    # script itself, it will refresh its state to account for potential changes.
+    #
+    # ===== Parameters
+    # path<Pathname, String>:: path that triggered event
+    # event<Symbol>:: event type (ignored for now)
+    #
+    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, event_type).call
+      end
+    end
+
+    # List of paths the script is monitoring.
+    #
+    # Basically this means all paths below current directoly recursivelly that
+    # match any of the rules' patterns, plus the script file.
+    #
+    # ===== Returns
+    # paths<Array[Pathname]>:: List of monitored paths
+    #
+    def monitored_paths
+      paths = Dir['**/*'].select do |path|
+        @script.patterns.any? {|p| path.match(p) }
+      end
+      paths.push(@script.path).compact!
+      paths.map {|path| Pathname(path).expand_path }
+    end
+  end
+end
+

data/vendor/watchr-0.5.7/lib/watchr/event_handlers/base.rb

@@ -0,0 +1,48 @@
+require 'observer'
+
+module Watchr
+  module EventHandler
+    class AbstractMethod < Exception #:nodoc:
+    end
+
+    # Base functionality mixin meant to be included in specific event handlers.
+    module Base
+      include Observable
+
+      # Notify that a file was modified.
+      #
+      # ===== Parameters
+      # path<Pathname, String>:: full path or path relative to current working directory
+      # event_type<Symbol>:: event type.
+      #--
+      # #changed and #notify_observers are Observable methods
+      def notify(path, event_type = nil)
+        changed(true)
+        notify_observers(path, event_type)
+      end
+
+      # Begin watching given paths and enter listening loop. Called by the controller.
+      #
+      # Abstract method
+      #
+      # ===== Parameters
+      # monitored_paths<Array(Pathname)>:: list of paths the application is currently monitoring.
+      #
+      def listen(monitored_paths)
+        raise AbstractMethod
+      end
+
+      # Called by the controller when the list of paths monitored by wantchr
+      # has changed. It should refresh the list of paths being watched.
+      #
+      # Abstract method
+      #
+      # ===== Parameters
+      # monitored_paths<Array(Pathname)>:: list of paths the application is currently monitoring.
+      #
+      def refresh(monitored_paths)
+        raise AbstractMethod
+      end
+    end
+  end
+end

data/vendor/watchr-0.5.7/lib/watchr/event_handlers/portable.rb

@@ -0,0 +1,55 @@
+module Watchr
+  module EventHandler
+    class Portable
+      include Base
+
+      attr_accessor :monitored_paths
+      attr_accessor :reference_mtime
+
+      def initialize
+        @reference_mtime = Time.now
+      end
+
+      # Enters listening loop.
+      #
+      # Will block control flow until application is explicitly stopped/killed.
+      #
+      def listen(monitored_paths)
+        @monitored_paths = monitored_paths
+        loop { trigger; sleep(1) }
+      end
+
+      # See if an event occured, and if so notify observers.
+      def trigger #:nodoc:
+        path, type = detect_event
+        notify(path, type) unless path.nil?
+      end
+
+      # Update list of monitored paths.
+      def refresh(monitored_paths)
+        @monitored_paths = monitored_paths
+      end
+
+      private
+
+      # Verify mtimes of monitored files.
+      #
+      # If the latest mtime is more recent than the reference mtime, return
+      # that file's path.
+      #
+      # ===== Returns
+      # path and type of event if event occured, nil otherwise
+      #
+      def detect_event
+        path = @monitored_paths.max {|a,b| a.mtime <=> b.mtime }
+
+        if path.mtime > @reference_mtime
+          @reference_mtime = path.mtime
+          [path, :modified]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/vendor/watchr-0.5.7/lib/watchr/event_handlers/unix.rb

@@ -0,0 +1,97 @@
+module Watchr
+  module EventHandler
+    class Unix
+      include Base
+
+      # Used by Rev. Wraps a monitored path, and Rev::Loop will call its
+      # callback on file events.
+      class SingleFileWatcher < Rev::StatWatcher #:nodoc:
+        class << self
+          # Stores a reference back to handler so we can call its #nofity
+          # method with file event info
+          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, 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
+
+      def initialize
+        SingleFileWatcher.handler = self
+        @loop = Rev::Loop.default
+      end
+
+      # Enters listening loop.
+      #
+      # Will block control flow until application is explicitly stopped/killed.
+      #
+      def listen(monitored_paths)
+        @monitored_paths = monitored_paths
+        attach
+        @loop.run
+      end
+
+      # Rebuilds file bindings.
+      #
+      # will detach all current bindings, and reattach the <tt>monitored_paths</tt>
+      #
+      def refresh(monitored_paths)
+        @monitored_paths = monitored_paths
+        detach
+        attach
+      end
+
+      private
+
+      # Binds all <tt>monitored_paths</tt> to the listening loop.
+      def attach
+        @monitored_paths.each {|path| SingleFileWatcher.new(path.to_s).attach(@loop) }
+      end
+
+      # Unbinds all paths currently attached to listening loop.
+      def detach
+        @loop.watchers.each {|watcher| watcher.detach }
+      end
+    end
+  end
+end