nestor 0.1.0

data/lib/nestor/cli.rb

@@ -0,0 +1,52 @@
+require "nestor"
+require "thor"
+
+module Nestor
+  class Cli < Thor # :nodoc:
+    desc("start", <<-EODESC.gsub(/^\s{6}/, ""))
+      Starts a continuous test server.
+    EODESC
+    method_options :strategy => "test/unit", :watcher => "rails", :script => nil, :debug => false, :include => []
+    def start
+      puts "Using #{options[:strategy].inspect} strategy"
+      begin
+        # Try the internal version
+        require "nestor/strategies/#{options[:strategy]}"
+      rescue LoadError
+        # Else fallback to something I'm not aware of right now
+        require options[:strategy]
+      end
+
+      puts "Using #{options[:watcher].inspect} watcher"
+      begin
+        require "nestor/watchers/#{options[:watcher]}"
+      rescue LoadError
+        # Fallback to something external again
+        require options[:watcher]
+      end
+
+      Watchr.options.debug = options[:debug]
+
+      if options[:script] then
+        puts "Launching with custom script #{options[:script].inspect}"
+      else
+        puts "Launching..."
+      end
+      Nestor::Watchers::Rails.run(:script => Pathname.new(options[:script]))
+    end
+
+    desc("customize PATH", <<-EODESC.gsub(/^\s{6}/, ""))
+      Copies the named script file to PATH to allow customizing.
+    EODESC
+    method_options :strategy => "test/unit", :watcher => "rails"
+    def customize(path)
+      puts "Using #{options[:watcher].inspect} watcher"
+      require "nestor/watchers/#{options[:watcher]}"
+
+      raise "Destination #{path.inspect} already exists: will not overwrite" if File.file?(path)
+      FileUtils.cp(Nestor::Watchers::Rails.path_to_script, path)
+
+      puts "Wrote #{options[:watcher]} script to #{path.inspect}"
+    end
+  end
+end

data/lib/nestor/machine.rb

@@ -0,0 +1,161 @@
+require "state_machine"
+
+module Nestor
+  # Implements the state machine that is at the heart of Nestor.
+  #
+  # == Usage
+  #
+  # In the Watchr script, use +@strategy+ to access an instance of this class.
+  #
+  # The available events you may call are:
+  #
+  # <tt>ready!</tt>:: Machine instances start in the +booting+ state.  Once the boot is complete,
+  #                   call +ready+ to indicate you are ready to process events.  The default
+  #                   rails template calls #ready when +test/test_helper.rb+ is loaded.
+  #
+  # <tt>changed!</tt>:: Tells the Machine a file changed.  The Watchr script and Strategy are
+  #                     responsible for assigning meaning to the file.  The default Watchr
+  #                     script knows how to map model, controller and view files to given
+  #                     tests, and the script thus only tells the Machine about test files.
+  #                     Nothing prevents another implementation from providing the actual
+  #                     implementation files and letting the Strategy decide later what to
+  #                     do about those.
+  #
+  # <tt>run_successful!</tt>:: Tells the Machine that the last build was successful.  This
+  #                            does not necessarily indicate a a completely green build: only
+  #                            that the last run was successful, given the focused files.
+  #
+  # <tt>run_failed!</tt>:: Tells the Machine there were one or more test failures or errors.
+  #                        Again, this doesn't mean the whole build failed: only the last couple
+  #                        of files had something that caused a failure.
+  #
+  # <tt>run!</tt>::  Tells the machine to tell the +#strategy+ to run the tests, given the current
+  #                  state of affairs.  This might be running all tests, or a subset if the Machine
+  #                  is currently focusing on some items.  A separate event is required by the
+  #                  Machine to allow coalescing multiple change events together.
+  #
+  class Machine
+    # The Machine actually delegates running the tests to another object, and this is it's reference.
+    attr_reader :strategy      # :nodoc:
+
+    # The list of files we are focusing on, as received by #changed!
+    attr_reader :focused_files # :nodoc:
+
+    # The last changed file.  Set by #changed!
+    attr_reader :changed_file  # :nodoc:
+
+    # The list of failing tests or examples being focused on right now
+    attr_reader :focuses       # :nodoc:
+
+    # +strategy+ is required, and must implement a couple of methods.  See Nestor::Strategies for the required calls.
+    def initialize(strategy)
+      super() # Have to specify no-args, or else it'll raise an ArgumentError
+
+      @strategy = strategy
+      @focused_files, @focuses = [], []
+
+      log_state_change
+    end
+
+    state_machine :initial => :booting do
+      event :ready do
+        transition any => :running_all
+      end
+
+      event :failed do
+        transition [:running_all, :running_multi, :running_focused] => :run_focused
+      end
+
+      event :successful do
+        transition :running_focused => :running_multi
+        transition :running_multi   => :running_all
+        transition :running_all     => :green
+      end
+
+      event :file_changed do
+        transition [:run_focused, :run_focused_pending] => :run_focused_pending, :if => :changed_file_in_focused_files?
+        transition [:run_focused_pending, :run_multi_pending, :run_focused] => :run_multi_pending
+        transition :green => :run_multi_pending
+      end
+
+      event :run do
+        transition :run_focused_pending => :running_focused
+        transition :run_multi_pending => :running_multi
+      end
+
+      after_transition  any  => any,              :do => :log_state_change
+      after_transition  :to  => :running_all,     :do => :run_all_tests
+      after_transition  :to  => :running_focused, :do => :run_focused_tests
+      after_transition  :to  => :running_multi,   :do => :run_multi_tests
+      before_transition :to  => :run_focused,     :do => :log_focus
+      before_transition :to  => [:run_focused_pending, :run_multi_pending],
+                                                  :do => :log_pending_run
+      after_transition  :on  => :file_changed,    :do => :add_changed_file_to_focused_files
+    end
+
+    # Indicates the run was succesful: a green build.  This does not indicate that the
+    # whole build was successful: only that the files that ran last were successful.
+    def run_successful!(files, tests)
+      successful!
+    end
+
+    # Indicates there were one or more failures.  +files+ lists the actual files
+    # that failed, while +tests+ indicates the test names or examples that failed.
+    def run_failed!(files, tests)
+      @focused_files, @focuses = files, tests
+      failed!
+    end
+
+    # Notifies the Machine that a file changed.  This might trigger a state change and schedule a build.
+    def changed!(file)
+      @changed_file = file
+      file_changed!
+    end
+
+    private
+
+    def run_all_tests
+      reset_focused_files
+      reset_focuses
+      @strategy.run_all
+    end
+
+    def run_multi_tests
+      reset_focuses
+      @strategy.run(focused_files)
+    end
+
+    def run_focused_tests
+      @strategy.run(focused_files, focuses)
+    end
+
+    def reset_focused_files
+      @focused_files.clear
+    end
+
+    def add_changed_file_to_focused_files
+      @focused_files << @changed_file unless @focused_files.include?(@changed_file)
+    end
+
+    def changed_file_in_focused_files?
+      @strategy.log("changed_file #{changed_file}, in focused_files? #{focused_files.inspect}")
+      focused_files.include?(changed_file)
+    end
+
+    def reset_focuses
+      focuses.clear
+    end
+
+    def log_state_change
+      @strategy.log("Machine entering state: #{state.inspect}")
+    end
+
+    def log_focus
+      @strategy.log("Focusing on #{focuses.inspect}")
+    end
+
+    def log_pending_run
+      @strategy.log("Run pending...  Waiting for go ahead")
+    end
+  end
+end

data/lib/nestor/strategies/test/unit.rb

@@ -0,0 +1,116 @@
+require "yaml"
+require "pathname"
+require "test/unit/ui/console/testrunner"
+
+module Nestor
+  module Strategies
+    module Test
+      class Unit
+        def initialize(root)
+          @root = Pathname.new(root).realpath
+        end
+
+        # Logs a message to STDOUT.  This implementation forks, so the #log method also
+        # provides the PID of the logger.
+        def log(message)
+          STDOUT.printf "[%d] %s - %s\n", Process.pid, Time.now.strftime("%H:%M:%S"), message
+          STDOUT.flush
+        end
+
+        # Runs absolutely all tests as found by walking test/.
+        def run_all
+          fork do
+            log "Run all tests"
+            test_files = Dir["test/**/*_test.rb"]
+            test_files.each {|f| log(f); load f}
+
+            ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+            test_runner = ::Nestor::Strategies::Test::TestRunner.new(nil)
+            result = ::Test::Unit::AutoRunner.run(false, nil, []) do |autorunner|
+              autorunner.runner = lambda { test_runner }
+            end
+
+            report(test_runner, test_files)
+          end
+        end
+
+        # Runs only the named files, and optionally focuses on only a couple of tests
+        # within the loaded test cases.
+        def run(test_files, focuses=[])
+          fork do
+            log "Running #{focuses.length} focused tests"
+            test_files.each {|f| log(f); load f}
+
+            ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+            test_runner = ::Nestor::Strategies::Test::TestRunner.new(nil)
+            result = ::Test::Unit::AutoRunner.run(false, nil, []) do |autorunner|
+              autorunner.runner = lambda { test_runner }
+              autorunner.filters << proc{|t| focuses.include?(t.method_name)} unless focuses.empty?
+            end
+
+            report(test_runner, test_files)
+          end
+        end
+
+        private
+
+        # Since we forked, we can't call into the Machine from the child process.  Upstream
+        # communications is implemented by writing new files to the filesystem and letting
+        # the parent process catch the changes.
+        def report(test_runner, test_files)
+          info = {"status" => test_runner.passed? ? "successful" : "failed", "failures" => {}}
+          failures = info["failures"]
+          test_runner.faults.each do |failure|
+            filename = if failure.respond_to?(:location) then
+                         failure.location.detect do |loc|
+                           filename = loc.split(":", 2).first
+                           test_files.detect {|tf| filename.include?(tf)}
+                         end
+                       elsif failure.respond_to?(:exception) then
+                         failure.exception.backtrace.detect do |loc|
+                           filename = loc.split(":", 2).first
+                           test_files.detect {|tf| filename.include?(tf)}
+                         end
+                       else
+                         raise "Unknown object type received as failure: #{failure.inspect} doesn't have #exception or #location methods."
+                       end
+
+            test_name = failure.test_name.split("(", 2).first.strip
+            if filename.nil? then
+              log("Could not map #{failure.test_name.inspect} to a specific test file: mapping to #{test_files.length}")
+              test_files.each do |tf|
+                failures[test_name] = tf
+              end
+            else
+              log("Failed #{failure.test_name.inspect} in #{filename.inspect}")
+              failures[test_name] = filename
+            end
+          end
+
+          File.open("tmp/nestor-results.yml", "w") {|io| io.write(info.to_yaml) }
+          log "Wrote #{failures.length} failure(s) to tmp/nestor-results.yml"
+        end
+      end
+
+      # A helper class that allows me to get more information from the build.
+      #
+      # This is something that definitely will change when Nestor is tested on Ruby 1.9.
+      class TestRunner < ::Test::Unit::UI::Console::TestRunner #:nodoc:
+        attr_reader :faults
+
+        # This is a duck-typing method.  Test::Unit's design requiers a #run method,
+        # but it is implemented as a class method.  I fake it here to allow me to
+        # pass an instance and have the actual TestRunner instance available afterwards.
+        def run(suite, output_level=NORMAL)
+          @suite = suite.respond_to?(:suite) ? suite.suite : suite
+          start
+        end
+
+        # Returns pass/fail status.
+        def passed?
+          @faults.empty?
+        end
+      end
+    end
+  end
+end

data/lib/nestor/strategies.rb

@@ -0,0 +1,18 @@
+module Nestor
+  # Nestor::Cli will require a file named +nestor/strategies/#{strategy_name}+.  If you want
+  # to provide custom strategies, make it available to Nestor using the correct path.
+  #
+  # Strategies are simple objects that implement the following protocol:
+  #
+  # <tt>log(message)</tt>:: Logs a simple message, either to the console or a logfile.
+  #                         The Machine will use the +log+ method to notify about it's
+  #                         state transitions.
+  #
+  # <tt>run_all</tt>:: Runs all the tests, no matter what.  In the Rails &
+  #                    +Test::Unit+ case, this means <tt>Dir["test/**/*_test.rb"]</tt>.
+  #
+  # <tt>run(tests_files, focused_cases=[])</tt>:: Runs only a subset of the tests, maybe
+  #                                               focusing on only a couple of tests / examples.
+  module Strategies
+  end
+end

data/lib/nestor/watchers/rails.rb

@@ -0,0 +1,56 @@
+require "watchr"
+require "pathname"
+
+module Nestor
+  module Watchers
+    # Knows how to map file change events from Rails conventions to the corresponding test case.
+    module Rails
+      # Launches a Watchr::Controller to and never returns.  The Controller will
+      # listen for file change events and trigger appropriate events on the Machine.
+      #
+      # By default, the Rails watcher will use the +Test::Unit+ strategy.
+      #
+      # @option options :strategy [Nestor::Strategies] The strategy to use.  Must be an instance of a class that implements the protocol defined in Nestor::Strategies.
+      # @option options :script The path to the Watchr script.
+      #
+      # @return Never...
+      def self.run(options={})
+        strategy = options[:strategy] || Nestor::Strategies::Test::Unit.new(Dir.pwd)
+        script = instantiate_script(options[:script])
+
+        strategy.log "Instantiating machine"
+        script.nestor_strategy = strategy
+        script.nestor_machine  = Nestor::Machine.new(strategy)
+        Watchr::Controller.new(script, Watchr.handler.new).run
+      end
+
+      def self.path_to_script
+        default_script_path
+      end
+
+      private
+
+      def self.default_script_path
+        Pathname.new(File.dirname(__FILE__) + "/rails_script.rb") 
+      end
+
+      def self.instantiate_script(path) #:nodoc:
+        # Use the default if none provided
+        path = default_script_path if path.nil?
+
+        script = Watchr::Script.new(path)
+        class << script
+          def nestor_machine=(m)
+            @machine = m
+          end
+
+          def nestor_strategy=(s)
+            @strategy = s
+          end
+        end
+
+        script
+      end
+    end
+  end
+end

data/lib/nestor/watchers/rails_script.rb

@@ -0,0 +1,83 @@
+def log(message) #:nodoc:
+  @strategy.log(message)
+end
+
+RAILS_ENV = "test" unless defined?(RAILS_ENV)
+log "Entering #{RAILS_ENV.inspect} environment"
+
+log "Creating tmp/ if it doesn't exist"
+Dir.mkdir("tmp") unless File.directory?("tmp")
+
+log "Preloading test/test_helper.rb"
+start_load_at = Time.now
+$LOAD_PATH.unshift "test" unless $LOAD_PATH.include?("test")
+require "test_helper"
+
+end_load_at = Time.now
+log "Waiting for changes (saving #{end_load_at - start_load_at} seconds per run)..."
+
+def sendoff(timeout=0.8, path="tmp/nestor-sendoff") #:nodoc:
+  Thread.start(timeout, path) do |timeout, path|
+    log "Sendoff pending #{timeout}..."
+    sleep timeout
+    File.open(path, "w") {|io| io.write(rand.to_s)}
+    log "Sendoff fired on #{path}"
+  end
+end
+
+def changed!(filename) #:nodoc:
+  @machine.changed! filename
+  sendoff
+end
+
+watch 'app/models/(.+)\.rb' do |md|
+  test_file = "test/unit/#{md[1]}_test.rb"
+  log "#{md[0].inspect} => #{test_file.inspect}"
+  changed! test_file if File.file?(test_file)
+end
+
+watch 'app/controllers/(.+)\.rb' do |md|
+  test_file = "test/functional/#{md[1]}_test.rb"
+  log "#{md[0].inspect} => #{test_file.inspect}"
+  changed! test_file if File.file?(test_file)
+end
+
+# It might be possible to run focused tests with the view name
+watch 'app/views/(.+)' do |md|
+  segments = md[1].split("/")
+  path     = segments[0..-2]
+  test_file = "test/functional/#{path.join("/")}_controller_test.rb"
+  log "#{md[0].inspect} => #{test_file.inspect}"
+  changed! test_file if File.file?(test_file)
+end
+
+watch 'config/' do |md|
+  @machine.reset!
+end
+
+watch 'test/test_helper\.rb' do |md|
+  @machine.reset!
+end
+
+watch 'test/(?:unit|functional|integration|performance)/.*' do |md|
+  log "#{md[0].inspect} => #{md[0].inspect}"
+  changed! md[0]
+end
+
+watch 'tmp/nestor-results.yml' do |md|
+  # Since we received the results, we must receive our child process' status, or
+  # else we'll have zombie processes lying around
+  Thread.start { Process.wait }
+
+  info = YAML.load_file(md[0])
+  log "New results in: #{info.inspect}"
+  failures = info["failures"]
+  @machine.send("run_#{info["status"]}!", failures.values.uniq, failures.keys)
+end
+
+watch 'tmp/nestor-sendoff' do |_|
+  log "Sendoff"
+  @machine.run!
+end
+
+@machine.ready!

data/lib/nestor/watchers.rb

@@ -0,0 +1 @@
+require "nestor/watchers/rails"

data/lib/nestor.rb

@@ -0,0 +1,11 @@
+require "watchr"
+require "nestor/machine"
+
+begin
+  require "ruby-debug"
+rescue LoadError
+  # Ignore: development dependency
+end
+
+module Nestor # :nodoc:
+end

data/spec/machine_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Nestor::Machine do
+  it "should accept a strategy on instantiation" do
+    strategy = mock.as_null_object
+    machine = Nestor::Machine.new(strategy)
+    machine.strategy.should be_equal(strategy) 
+  end
+end
+
+describe Nestor::Machine do
+  before(:each) do
+    @strategy = mock
+    @strategy.stub(:run_all)
+  end
+
+  it "should start in the :running_all state" do
+    @machine = Nestor::Machine.new(@strategy)
+    machine.should be_running_all
+  end
+
+  it "should tell the strategy to run all tests" do
+    strategy = mock
+    strategy.should_receive(:run_all).with().once
+    Nestor::Machine.new(strategy)
+  end
+
+  it "should transition to :green when calling #successful" do
+    machine.successful
+    machine.should be_green
+  end
+
+  it "should transition to :run_focused when calling #failed" do
+    machine.failed
+    machine.should be_run_focused
+  end
+
+  def machine
+    @machine ||= Nestor::Machine.new(@strategy)
+  end
+end
+
+describe Nestor::Machine, "when in the run_focused state" do
+  before(:each) do
+    @strategy = mock
+    @strategy.stub(:run_all)
+    @machine = Nestor::Machine.new(@strategy)
+    @machine.failed
+  end
+
+  it "should transition to :running_focused when calling #changed!(filename)" do
+    @strategy.should_receive(:run).with(["spec/machine_spec.rb"])
+    @machine.changed!("spec/machine_spec.rb")
+    @machine.should be_running_focused
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'nestor'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/vendor/watchr-0.5.7/.gitignore

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

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