smparkes-watchr 0.5.7

data/.gitignore

@@ -0,0 +1,6 @@
+doc/
+pkg/
+bk/
+.wiki
+.yardoc
+/*.gem

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/LICENSE

@@ -0,0 +1,19 @@
+Copyright © 2009 Martin Aumont (mynyml)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

data/Manifest

@@ -0,0 +1,30 @@
+.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/event_handlers/rev.rb
+lib/watchr/event_handlers/em.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_rev.rb
+test/event_handlers/test_em.rb
+test/test_controller.rb
+test/test_helper.rb
+test/test_script.rb
+test/test_watchr.rb
+watchr.gemspec

data/README.rdoc

@@ -0,0 +1,82 @@
+=== Summary
+
+This is a fork of the Watchr gem at git://github.com/mynyml/watchr.git.
+
+The are a number of differences. It's been ported to EventMachine for
+file-events and has some extensions for how watches can be written.
+
+== EventMachine
+
+Not much to say. It supports EM as well as Rev. The default is still
+Rev. To use EventMachine, after installing the EM gem, I just add
+
+     begin; require 'watchr/event_handlers/em'; rescue LoadError; end
+
+to my <tt>watchr.cnf</tt>. It'll use the first required backend, or
+Rev if none are (and Rev is installed).  There may be better ways to
+do this.
+
+=== Event processing extensions
+
+I made several changes to the way events are created/processed, mostly
+to make my <tt>watchr.cnf</tt> work:
+
+  #!/usr/bin/env watchr
+
+  begin; require 'watchr/event_handlers/em'; rescue LoadError; end
+
+  watch( %r(.*), :modified, lambda { |md| File.directory? md[0] } ) do |md|
+    raise Watchr::Refresh
+  end
+
+  watch( %r((public/.*)\.haml$), [ :created, :modified ] ) do |md|
+    cmd = "rm -f #{md[1]}.html && haml -f html5 #{md[0]} #{md[1]}.html && chmod 444 #{md[1]}.html"
+    puts cmd
+    system cmd
+    if  $?.signaled? && $?.termsig == 2
+      Process.kill 2, 0
+    end
+  end
+
+  watch( %r((spec/.*[Ss]pec)\.(html|js)$), [ :load, :created, :modified ] ) do |md|
+    cmd = "jazrb #{md[0]}"
+    puts cmd
+    system cmd
+    if  $?.signaled? && $?.termsig == 2
+      Process.kill 2, 0
+    end
+  end
+
+The purpose of the first watch is to cause watchr to refresh when
+directories change. This allows new files to be picked up.  The watch
+pattern matches all files in the current directory tree (though not
+<tt>.</tt> itself), and watches for <tt>:modified</tt> events. It adds
+an extra lambda that is processed while looking at file paths: only
+directories will get watches put on them. (Otherwise <tt>%r(.*)</tt> would put
+watches on every file/directory in the tree, which seems kinda bad.
+
+The second watch looks for HAML files in my public directory and
+automatically converts them to HTML. These are static files, not
+served by an app server like Rails, but even with static files, I hate
+writing raw HTML. The extension here is that instead of a single event
+type, I can pass an array. In addition to the <tt>:modified</tt>,
+event, this will get called when watchr notes that a new file of this
+type has appeared. (Note this works starting from watchr's first pass;
+files created while watchr wasn't running don't count).
+
+Then final watch looks for JavaScript and HTML spec files and runs
+them under jazrb (see http://github.com/smparkes/jazrb if
+interested). This case is similar to the previous but also adds the
+<tt>:load</tt> event. This event gets fired the first time a file is
+seen after watchr starts. This allows watchr to run all the specs when
+first started, similar to what autotest does.
+
+=== Things to do
+
+1. Batch up specs instead of running them individually (not a big deal for jazrb and haml; a big detail for rspec)
+
+1. Integrate upstream (if the want it)
+
+1. Move directory watch into watchr itself
+
+1. Handle user interrupt processing more systematically

data/Rakefile

@@ -0,0 +1,51 @@
+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
+
+task :default => "test:all"

data/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/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)).run
+

data/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/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

@@ -0,0 +1,101 @@
+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'
+
+  autoload :Script,     'watchr/script'
+  autoload :Controller, 'watchr/controller'
+
+  module EventHandler
+    autoload :Base,     'watchr/event_handlers/base'
+    autoload :Unix,     'watchr/event_handlers/unix'
+    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'
+            Watchr::EventHandler::Unix.default
+          else
+            Watchr::EventHandler::Portable
+        end
+    end
+  end
+end