nestor 0.1.1 → 0.2.0

data/lib/nestor/cli.rb

@@ -3,28 +3,21 @@ require "thor"
 
 module Nestor
   class Cli < Thor # :nodoc:
+    default_task :start
+
     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
+      Specify the framework and test library using --framework and --testlib.
+      Valid options are:
+        --framework: rails
+        --testlib:   test/unit
 
+      Use --quick to boot without running the full test suite on startup.
+      --debug writes extra Watchr debug messages to STDOUT.
+    EODESC
+    method_options :framework => "rails", :testlib => "test/unit", :script => nil, :debug => false, :quick => false, :require => []
+    def start
       Watchr.options.debug = options[:debug]
 
       if options[:script] then
@@ -32,21 +25,64 @@ module Nestor
       else
         puts "Launching..."
       end
-      Nestor::Watchers::Rails.run(:script => options[:script] ? Pathname.new(options[:script]) : nil)
+
+      puts "Using #{options[:framework].inspect} framework with #{options[:testlib].inspect} as the testing library"
+      mapper      = mapper_instance(options[:framework], options[:testlib])
+      machine     = Nestor::Machine.new(mapper, :quick => options[:quick])
+
+      script_path = options[:script] ? Pathname.new(options[:script]) : nil
+      script      = Nestor::Script.new(script_path || mapper.class.default_script_path)
+
+      options[:require].each do |path|
+        puts "Loading #{path.inspect} plugin"
+        require path
+      end
+
+      script.nestor_machine = machine
+      Watchr::Controller.new(script, Watchr.handler.new).run
     end
 
     desc("customize PATH", <<-EODESC.gsub(/^\s{6}/, ""))
       Copies the named script file to PATH to allow customizing.
+      Will not overwrite existing files, unless --force is specified.
     EODESC
-    method_options :strategy => "test/unit", :watcher => "rails"
+    method_options :framework => "rails", :testlib => "test/unit", :force => false
     def customize(path)
-      puts "Using #{options[:watcher].inspect} watcher"
-      require "nestor/watchers/#{options[:watcher]}"
+      raise "Destination #{path.inspect} already exists: will not overwrite" if !options[:force] && File.file?(path)
 
-      raise "Destination #{path.inspect} already exists: will not overwrite" if File.file?(path)
-      FileUtils.cp(Nestor::Watchers::Rails.path_to_script, path)
+      puts "Using #{options[:framework].inspect} framework with #{options[:testlib].inspect} as the testing library"
+      klass = mapper_class(options[:framework], options[:testlib])
+      FileUtils.cp(klass.default_script_path, path)
 
-      puts "Wrote #{options[:watcher]} script to #{path.inspect}"
+      puts "Wrote #{klass.name} script to #{path.inspect}"
+    end
+
+    private
+
+    def require_path(*paths)
+      require "nestor/mappers/#{paths.join("/")}"
+    rescue LoadError
+      require paths.join("/")
+    end
+
+    def mapper_class(framework, testlib)
+      require_path(options[:framework], options[:testlib])
+      [framework.split("/"), testlib.split("/")].flatten.inject(Nestor::Mappers) do |root, component|
+        root.const_get(camelize(component))
+      end
+    end
+
+    def mapper_instance(framework, testlib)
+      mapper_class(framework, testlib).new
+    end
+
+    # Copied from ActiveSupport 2.3.4
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
     end
   end
 end

data/lib/nestor/machine.rb

@@ -5,7 +5,7 @@ module Nestor
   #
   # == Usage
   #
-  # In the Watchr script, use +@strategy+ to access an instance of this class.
+  # In the Watchr script, use +@mapper+ to access an instance of this class.
   #
   # The available events you may call are:
   #
@@ -13,12 +13,12 @@ module Nestor
   #                   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
+  # <tt>changed!</tt>:: Tells the Machine a file changed.  The Watchr script and mapper 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
+  #                     implementation files and letting the mapper decide later what to
   #                     do about those.
   #
   # <tt>run_successful!</tt>:: Tells the Machine that the last build was successful.  This
@@ -29,14 +29,14 @@ module Nestor
   #                        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
+  # <tt>run!</tt>::  Tells the machine to tell the +#mapper+ 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:
+    attr_reader :mapper        # :nodoc:
 
     # The list of files we are focusing on, as received by #changed!
     attr_reader :focused_files # :nodoc:
@@ -47,19 +47,24 @@ module Nestor
     # 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)
+    # The options as passed to #new.
+    attr_reader :options       # :nodoc:
+
+    # +mapper+ is required, and must implement a couple of methods.  See {Nestor::Mappers} for the required calls.
+    def initialize(mapper, options={})
+      @options = options
       super() # Have to specify no-args, or else it'll raise an ArgumentError
 
-      @strategy = strategy
+      @mapper = mapper
       @focused_files, @focuses = [], []
 
       log_state_change
     end
 
-    state_machine :initial => :booting do
+    state_machine :initial => lambda {|machine| machine.options[:quick] ? :green : :booting} do
       event :ready do
-        transition any => :running_all
+        transition :booting => :running_all
+        transition :green   => same # Quick boot: skips initial test run
       end
 
       event :failed do
@@ -73,6 +78,7 @@ module Nestor
       end
 
       event :file_changed do
+        transition [:running_all, :running_multi, :running_focused] => same
         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
@@ -84,6 +90,10 @@ module Nestor
         transition :run_multi_pending => :running_multi
       end
 
+      event :unfocus do
+        transition any => :running_all
+      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
@@ -94,23 +104,31 @@ module Nestor
       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!
+    # Delegate to +@mapper+.
+    def log(*args)
+      @mapper.log(*args)
     end
 
     # Notifies the Machine that a file changed.  This might trigger a state change and schedule a build.
     def changed!(file)
+      mapped_files = mapper.map(file)
+      case mapped_files
+      when []  # Run all tests
+        unfocus!
+      when nil # Reset
+        reset!
+      else
+        mapped_files.each do |mapped_file|
+          mapper.log "#{file} => #{mapped_file}"
+          self.changed_file = mapped_file
+          file_changed!
+        end
+      end
+    end
+
+    def changed_file=(file)
+      raise ArgumentError, "Only accepts a single file at a time, got #{file.inspect}" unless String === file
       @changed_file = file
-      file_changed!
     end
 
     private
@@ -118,16 +136,25 @@ module Nestor
     def run_all_tests
       reset_focused_files
       reset_focuses
-      @strategy.run_all
+      process!(@mapper.run_all)
     end
 
     def run_multi_tests
       reset_focuses
-      @strategy.run(focused_files)
+      process!(@mapper.run(focused_files))
     end
 
     def run_focused_tests
-      @strategy.run(focused_files, focuses)
+      process!(@mapper.run(focused_files, focuses))
+    end
+
+    def process!(info)
+      @mapper.log(info.inspect)
+      return successful! if info[:passed]
+
+      files, tests = info[:failures].values.uniq, info[:failures].keys
+      @focused_files, @focuses = files, tests
+      failed!
     end
 
     def reset_focused_files
@@ -135,11 +162,11 @@ module Nestor
     end
 
     def add_changed_file_to_focused_files
-      @focused_files << @changed_file unless @focused_files.include?(@changed_file)
+      @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}")
+      @mapper.log("changed_file #{changed_file}, in focused_files? #{focused_files.inspect}")
       focused_files.include?(changed_file)
     end
 
@@ -148,15 +175,15 @@ module Nestor
     end
 
     def log_state_change
-      @strategy.log("Machine entering state: #{state.inspect}")
+      @mapper.log("Machine entering state: #{state.inspect}")
     end
 
     def log_focus
-      @strategy.log("Focusing on #{focuses.inspect}")
+      @mapper.log("Focusing on #{focuses.inspect}")
     end
 
     def log_pending_run
-      @strategy.log("Run pending...  Waiting for go ahead")
+      @mapper.log("Run pending...  Waiting for go ahead")
     end
   end
 end

data/lib/nestor/mappers/rails/test/rails_test_unit.rb

@@ -0,0 +1,58 @@
+def log(message) #:nodoc:
+  @machine.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 in #{timeout}s..."
+    sleep timeout
+    File.open(path, "w") {|io| io.write(rand.to_s)}
+    log "Sendoff fired on #{path}"
+  end
+end
+
+def changed!(filename) #:nodoc:
+  return if File.directory?(filename)
+  @machine.changed! filename
+  sendoff
+end
+
+watch 'config/(?:.+)\.(?:rb|ya?ml)' do |md|
+  changed! md[0]
+end
+
+watch '(?:app|test)/.+\.rb' do |md|
+  changed! md[0]
+end
+
+watch 'app/views/.+' do |md|
+  changed! md[0]
+end
+
+watch 'db/schema.rb' do |md|
+  log "Detected changed schema: preparing test DB"
+  system("rake db:test:prepare")
+  changed! md[0]
+end
+
+# This is only to trigger the tests after a slight delay, but from the main thread.
+watch 'tmp/nestor-sendoff' do |_|
+  log "Sendoff"
+  @machine.run!
+end
+
+@machine.ready!

data/lib/nestor/mappers/rails/test/unit.rb

@@ -0,0 +1,259 @@
+require "yaml"
+require "pathname"
+require "test/unit/ui/console/testrunner"
+
+# Just declare the module to prevent deeply nested code below
+module Nestor
+  module Mappers
+    module Rails
+    end
+  end
+end
+
+module Nestor::Mappers::Rails
+  module Test
+    class Unit
+      # Returns the path to the script this {Mapper} uses.
+      def self.default_script_path
+        Pathname.new(File.dirname(__FILE__) + "/rails_test_unit.rb")
+      end
+
+      # Utility method to extract data from a Test::Unit failure.
+      #
+      # @param failure [Test::Unit::Failure, Test::Unit::Error] The Test::Unit failure or error from which to extract information.
+      # @param test_files [Array<String>] The list of files that might have generated this failure.  This is used to detect the file that caused the failure.
+      #
+      # @return [String, String] Returns the filename and test name as a 2 element Array.
+      def self.parse_failure(failure, test_files)
+        filename = if failure.respond_to?(:location) then
+                     failure.location.map do |loc|
+                       filename = loc.split(":", 2).first
+                       test_files.detect {|tf| filename.include?(tf)}
+                     end.compact.first
+                   elsif failure.respond_to?(:exception) then
+                     failure.exception.backtrace.map do |loc|
+                       filename = loc.split(":", 2).first
+                       loc = loc[1..-1] if loc[0,1] == "/"
+                       test_files.detect {|tf| filename.include?(tf)}
+                     end.compact.first
+                   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.sub(/\.$/, "")
+
+        [filename, test_name]
+      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
+        receive_results do
+          log "Run all tests"
+          test_files = load_test_files(["test"])
+
+          ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+          test_runner = ::Nestor::Mappers::Rails::Test::TestRunner.new(nil)
+          result = ::Test::Unit::AutoRunner.run(false, nil, []) do |autorunner|
+            autorunner.runner = lambda { test_runner }
+          end
+
+          # Returns a Hash which the parent process will retrieve
+          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=[])
+        receive_results do
+          log "Running #{focuses.length} focused tests"
+          load_test_files(test_files)
+
+          ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+          test_runner = ::Nestor::Mappers::Rails::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
+
+          # Returns a Hash the parent process will retrieve
+          report(test_runner, test_files)
+        end
+      end
+
+      # Given a path, returns an Array of strings for the tests that should be run.
+      #
+      # This implementation maps +app/models+ to +test/unit+, +app/controllers+ and +app/views+ to +test/functional+.
+      # It is not the responsibility of #map to determine if the files actually exist on disk.  The {Nestor::Machine}
+      # will verify the files exist before attempting to run them.
+      #
+      #
+      # @example
+      # 
+      #   mapper = Nestor::Mappers::Rails::Test::Unit.new
+      #   mapper.map("app/models/user.rb")
+      #   #=> ["test/unit/user_test.rb"]
+      #   mapper.map("app/helpers/users_helper.rb")
+      #   #=> ["test/unit/helpers/users_helper.rb", "test/functional/users_controller_test.rb"]
+      #
+      #   # Mapper is saying to re-run all functional tests
+      #   mapper.map("app/controller/application_controller.rb")
+      #   #=> ["test/functional/"]
+      #
+      #   # Mapper is saying to run all tests
+      #   mapper.map("config/environment.rb")
+      #   #=> []
+      #
+      # @param path [String] A relative path to a file in the project.
+      # @return [Array<String>, nil] One or more paths the {Nestor::Machine} should run in response to the change.
+      #   It is entirely possible and appropriate that this method return an empty array, which implies to run
+      #   all tests.  If a path points to a directory, this implies running all tests under that directory.
+      #   Returning +nil+ implies no tests need to run (such as when editing a README).
+      def map(path)
+        case path
+        when %r{^app/.+/(.+_observer)\.rb$}              # Has to be first, or app/models might kick in first
+          orig, plain  = $1, $1.sub("_observer", "")
+          ["test/unit/#{orig}_test.rb", "test/unit/#{plain}_test.rb"]
+
+        when "app/controllers/application_controller.rb" # Again, special cases first
+          ["test/functional/"]
+
+        when "app/helpers/application_helper.rb"         # Again, special cases first
+          ["test/unit/helpers/", "test/functional/"]
+
+        when %r{^app/models/(.+)\.rb$}, %r{^lib/(.+)\.rb$}
+          ["test/unit/#{$1}_test.rb"]
+
+        when %r{^app/controllers/(.+)\.rb$}
+          ["test/functional/#{$1}_test.rb"]
+
+        when %r{^app/views/(.+)/(.+)\.\w+$}
+          ["test/functional/#{$1}_controller_test.rb"]
+
+        when %r{^app/helpers/(.+)_helper\.rb$}
+          ["test/unit/helpers/#{$1}_helper_test.rb", "test/functional/#{$1}_controller_test.rb"]
+
+        when %r{^(?:test/test_helper.rb|config/.+\.(?:rb|ya?ml|xml)|db/schema\.rb)$}
+          # Rerun all tests because something fundamental changed
+          []
+
+        when %r{^test/.+_test.rb}
+          # Rerun the sole test when it's a test
+          Array(path)
+
+        else
+          # I don't know how to map this, so it's probably a README or something
+          nil
+        end
+      end
+
+      private
+
+      def setup_lifeline
+        ppid = Process.ppid
+        log "Setting up lifeline on #{Process.pid} for #{Process.ppid}"
+
+        Thread.start do
+          sleep 0.5
+          next if ppid == Process.ppid
+
+          # Parent must have died because we don't have the same parent PID
+          # Die ourselves
+          log "Dying because parent changed"
+          exit!
+        end
+      end
+
+      def receive_results
+        rd, wr = IO.pipe
+        fork do
+          log "Setting up lifeline"
+          setup_lifeline
+
+          log "Closing read-end of the pipe"
+          rd.close
+
+          log "Doing whatever..."
+          info = yield
+
+          log "Returning YAML info to parent process"
+          wr.write info.to_yaml
+        end
+
+        log "Closing write-end of the pipe"
+        wr.close
+
+        log "Waiting for child process"
+        Process.wait
+
+        info = YAML.load(rd.read)
+      end
+
+      def load_test_files(test_files)
+        test_files.inject([]) do |memo, f|
+          case
+          when File.directory?(f)
+            Dir["#{f}/**/*_test.rb"].each do |f1|
+              log(f1)
+              load f1
+              memo << f1
+            end
+          when File.file?(f)
+            log(f)
+            load f
+            memo << f
+          else
+            # Ignore
+          end
+
+          memo
+        end
+      end
+
+      # Print to STDOUT the results of the run.  The parent's listening on the pipe to get the data.
+      def report(test_runner, test_files, io=STDOUT)
+        info = {:passed => test_runner.passed?, :failures => {}}
+        failures = info[:failures]
+        test_runner.faults.each do |failure|
+          filename, test_name = self.class.parse_failure(failure, test_files)
+          if filename.nil? then
+            log("Could not map #{failure.test_name.inspect} to a specific test file: mapping to #{test_files.length} files")
+            failures[test_name] = test_files
+          else
+            log("Failed #{failure.test_name.inspect} in #{filename.inspect}")
+            failures[test_name] = filename
+          end
+        end
+
+        info
+      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

data/lib/nestor/mappers.rb

@@ -0,0 +1,26 @@
+module Nestor
+  # {Nestor::Cli} will require a file named +nestor/mappers/#{framework}/#{test_framework}+.  If you want
+  # to provide custom mappers, it is possible to do so.
+  #
+  # Mappers are simple objects that implement the following protocol:
+  #
+  # <tt>default_script_path</tt>:: Class method to return the path to the default Watchr script.
+  #                                This *must* be a physical file on the filesystem, as Watchr
+  #                                cannot accept anything else at the moment.
+  #
+  # <tt>log(message)</tt>:: Logs a simple message, either to the console or a logfile.
+  #                         The {Nestor::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 {Nestor::Mappers::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.
+  #
+  # <tt>map(file)</tt>:: Given an implementation file, returns the corresponding test to run.
+  #                      {Nestor::Mappers::Rails::Test::Unit} maps +app/models/user.rb+ to
+  #                      +test/unit/user_test.rb+.
+  module Mappers
+  end
+end

data/lib/nestor/script.rb

@@ -0,0 +1,9 @@
+module Nestor
+  class Script < Watchr::Script
+    # Let's the script have a reference to the machine, to generate events.
+    # The actual instance variable name is +@machine+, not +@nestor_machine+.
+    def nestor_machine=(machine)
+      @machine = machine
+    end
+  end
+end

data/lib/nestor.rb

@@ -1,5 +1,6 @@
 require "watchr"
 require "nestor/machine"
+require "nestor/script"
 
 begin
   require "ruby-debug"