autotest-run_dependencies 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2009 Toby Clemson
+
+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/README.rdoc

@@ -0,0 +1,130 @@
+= Autotest::RunDependencies
+
+* Author: Toby Clemson (tobyclemson@gmail.com)
+
+== DESCRIPTION:
+
+This gem provides a mechanism through which it is possible to specify that an
+arbitrary number of external dependencies are satisfied before a test run can
+be executed.
+
+Dependencies are added by specifying a name, command, satisfied_regexp and 
+errors_regexp parameter for each. The command refers to a script that is run 
+to satisfy or test the dependency. If the output of the command (either 
+to standard output or standard error) matches the satisfied_regexp then the 
+dependency is considered met otherwise any lines in the output matching 
+errors_regexp are output and the dependency test waits for changes to the 
+codebase before trying to satisfy the dependency again.
+
+By default, the output is colourised in green if a dependency is satisfied 
+and red if a dependency is not satisfied. This colourisation can be turned 
+off if required.
+
+== REQUIREMENTS:
+
+* ZenTest >= 3.9.0
+
+== INSTALL:
+
+The gem can be installed using the following command:
+
+  sudo gem install autotest-run_dependencies
+
+== SETUP & CONFIGURATION:
+
+To add a dependency to the autotest test runs for a particular project, add
+the following to a .autotest file in the root of your project:
+  
+  require "autotest/run_requirements"
+
+  Autotest::RunDependencies.add do |dependency|
+    dependency.name =             "dependency name"   # used to identify the dependency
+    dependency.command =          "command_or_script" # the command to run
+    dependency.satisfied_regexp = /success/           # a regexp matching the output if successful
+    dependency.errors_regexp =    /error: (.*)/       # a regexp matching errors in the command output
+  end
+  
+The only required parameters are command and satisfied_regexp. This call
+automatically registers your dependency with autotest so that it will run 
+before every test autotest test run.
+
+By default the status messages are coloured green for success, red for 
+failure. This can be turned off by setting colourised_output to false:
+
+  Autotest::RunDependencies.colourised_output = false
+
+== EXAMPLE
+
+Using JRuby it is possible to use RSpec to specify Java code. In such an 
+instance it is required that the codebase compiles successfully before the
+specs are run against it. Many Java developers use the popular 'ant' tool to 
+compile their code and so here we will assume the codebase is compiled using
+the command 'ant clean jar'. This dependency can be accomplished using 
+Autotest::RunDependencies by creating a .autotest file in your project root 
+containing the following:
+
+  require "autotest/run_requirements"
+  
+  Autotest::RunDependencies.add do |dependency|
+    dependency.name =             "codebase compiles successfully"
+    dependency.command =          "ant clean jar"
+    dependency.satisfied_regexp = /^BUILD SUCCESSFUL$/
+    dependency.errors_regexp =    /^\s*\[javac\]\s(.*)$/
+  end
+  
+This ensures that the command "ant clean jar" is called and outputs 
+'BUILD SUCCESSFUL' before the test suite is run. If the build fails,
+each line beginning with '[javac]' is output and the dependency test waits 
+for the compile errors to be fixed before rerunning the build.
+
+You may also need to set up a mapping from the Java source files to spec 
+files. Assuming the source files are in a directory 'src/' and that Java
+classes use camel case (SomeClass.java) whilst specification files use
+underscore separated lowercase (some_class_spec.rb) this can be accomplished 
+using: (conversion code taken from ActiveSupport)
+
+  Autotest.add_hook :initialize do |autotest|
+    autotest.add_mapping(%r%^src/(.*)\.java$%) { |_, m|
+      ruby_style_name = m[1].gsub(
+        /([A-Z]+)([A-Z][a-z])/,'\1_\2'
+      ).gsub(
+        /([a-z\d])([A-Z])/,'\1_\2'
+      ).tr("-", "_").downcase
+      ["spec/#{ruby_style_name}_spec.rb"]
+    }
+    false # important: allows other hooks to be called
+  end
+
+== DEVELOPMENT:
+
+The code is hosted on github at 
+http://www.github.com/tobyclemson/autotest-run_requirements and so forking is
+encouraged.
+
+Alternatively, suggestions for improvements are welcome at my email address
+tobyclemson@gmail.com
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Toby Clemson
+
+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/Rakefile

@@ -0,0 +1,43 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+require 'jeweler'
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'doc'
+  rd.title = 'Autotest::RunDependencies RDoc Documentation'
+end
+
+Spec::Rake::SpecTask.new 
+
+Jeweler::Tasks.new do |gemspec|
+  gemspec.name = "autotest-run_dependencies"
+  gemspec.summary = "Test dependencies for autotest."
+  gemspec.description = <<EOF
+This gem provides a mechanism through which it is possible to specify that 
+an arbitrary number of external dependencies are satisfied before a test 
+run can be executed.
+
+Dependencies are added by specifying a name, command, satisfied_regexp and 
+errors_regexp parameter for each. The command refers to a script that is 
+run to satisfy or test the dependency. If the output of the command 
+(either to standard output or standard error) matches the satisfied_regexp 
+then the dependency is considered met otherwise any lines in the output 
+matching errors_regexp are output and the dependency test waits for changes 
+to the codebase before trying to satisfy the dependency again.
+EOF
+  gemspec.email = "tobyclemson@gmail.com"
+  gemspec.homepage = "http://github.com/tobyclemson/autotest-run_dependencies"
+  gemspec.authors = ["Toby Clemson"]
+  gemspec.add_dependency('ZenTest', '>= 3.9.0')
+  gemspec.files.exclude ".gitignore"
+  gemspec.rdoc_options << '--main'  << 'README.rdoc' << 
+                          '--title' << 'Autotest::RunDependencies RDoc Documentation' << 
+                          '--line-numbers'
+  gemspec.development_dependencies << 'rspec'
+end
+
+Jeweler::GemcutterTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/autotest-run_dependencies.rb

@@ -0,0 +1,11 @@
+$:.unshift(
+  File.dirname(__FILE__)
+) unless 
+  $:.include?(File.dirname(__FILE__)) || 
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require File.join(File.dirname(__FILE__), 'autotest', 'run_dependencies')
+
+class Autotest::RunDependencies
+  VERSION  = '0.1'
+end

data/lib/autotest/run_dependencies.rb

@@ -0,0 +1,214 @@
+require 'rubygems'
+require 'autotest'
+require 'ostruct'
+
+# Autotest::RunDependencies
+#
+# == FEATURES:
+# * Allows an arbitrary number of dependencies to be set that must be 
+#   satisfied before a test run is executed.
+# * The dependencies take the form of scripts that output to stdout or stderr.
+# * The dependency is considered satisfied if the output matches some user
+#   specified regular expression.
+# * If the dependency is not satisfied, a list of errors is printed where
+#   each error is a match of the user supplied errors regular expression.
+# * By default, output is colourised green on success, red on failure.
+# * Colourisation can be turned off.
+#
+# == SYNOPSIS:
+# PROJECT_ROOT/.autotest
+#   require 'autotest/run_dependencies.rb'
+#   
+#   # Add a dependency to the run dependencies
+#   Autotest::RunDependencies.add do |dependency|
+#     dependency.name = 'some dependency'
+#     dependency.command = 'echo "success"'
+#     dependency.satisfied_regexp = /success/
+#     dependency.errors_regexp = /error (.*)/
+#   end
+class Autotest::RunDependencies
+  
+  attr_accessor :name,
+                :command, 
+                :satisfied_regexp, 
+                :errors_regexp, 
+                :last_dependency_check_time,
+                :autotest_instance
+  
+  # By default the output produced is colourised.
+  @@colourise_output = true
+  
+  class << self
+    # Returns true if Autotest::RunDependencies is currently 
+    # configured to colourise its output, false otherwise.
+    def colourise_output
+      @@colourise_output
+    end
+    alias_method :colorize_output, :colourise_output 
+  
+    # Sets whether or not Autotest::RunDependencies should colourise
+    # its output.
+    def colourise_output=(boolean)
+      @@colourise_output = boolean
+    end
+    alias_method :colorize_output=, :colourise_output=
+  end
+  
+  # Adds a test dependency to any autotest test run.
+  #
+  # Expects a block to be supplied that sets the dependency parameters, e.g.,
+  #
+  #   Autotest::RunDependencies.add do |dependency|
+  #     dependency.name = 'some dependency'
+  #     dependency.command = 'echo "success"'
+  #     dependency.satisfied_regexp = /success/
+  #     dependency.errors_regexp = /error (.*)/
+  #   end
+  #
+  # Returns the dependency (an instance of Autotest::RunDependencies). 
+  # 
+  # It is possible not to pass a block and set the parameters on the returned 
+  # object but if a dependency object has no #command and #satisfied_regexp 
+  # set then on calling #ensure_dependency_is_satisfied a RuntimeError is 
+  # raised.
+  # 
+  # The method also registers the relevant hooks with Autotest so that the 
+  # dependency is required to be satisfied before the test run.
+  def self.add(&block)
+    parameters = OpenStruct.new
+    block.call(parameters) if block
+    dependency = self.new(
+      :name => parameters.name,
+      :command => parameters.command,
+      :satisfied_regexp => parameters.satisfied_regexp,
+      :errors_regexp => parameters.errors_regexp
+    )
+
+    Autotest.add_hook(:initialize) do |autotest|
+      dependency.autotest_instance = autotest
+      false
+    end
+
+    Autotest.add_hook(:run_command) do |autotest|
+      dependency.ensure_dependency_is_satisfied
+      false
+    end
+
+    Autotest.add_hook(:interrupt) do |autotest|
+      dependency.reset
+      false
+    end
+    
+    return dependency
+  end
+                
+  # Creates an instance of Autotest::RunDependencies.
+  #
+  # The optional _options_ hash can contain values for the keys :name, 
+  # :command, :satisfied_regexp and :errors_regexp. Any other entries will be
+  # ignored. The values of the parameters are used as default values for the
+  # instance's attributes.
+  def initialize(options = {})
+    self.name = options[:name]
+    self.command = options[:command]
+    self.satisfied_regexp = options[:satisfied_regexp]
+    self.errors_regexp = options[:errors_regexp]
+    self.last_dependency_check_time = Time.at(0)
+  end
+  
+  # Runs the dependency test command if any files have been modified since the
+  # last time the dependency was checked. If the dependency is satisfied, 
+  # i.e., the output of the command matches the regular expression in 
+  # the #satisfied_regexp attribute, then the test run is allowed to continue, 
+  # otherwise the method prints any lines in the output that match the regular 
+  # expression in the #errors_regexp attribute and waits for further changes 
+  # to the codebase before trying to test the dependency again.
+  # 
+  # This method raises a RuntimeError unless both the #command and 
+  # #satisfied_regexp attributes are set.
+  def ensure_dependency_is_satisfied
+    unless self.command and self.satisfied_regexp
+      raise(
+        RuntimeError, 
+        "Dependencies must have at least a command and a satisfied_regexp " +
+        " set."
+      )
+    end
+    if find_changed_files
+      puts "\nChecking dependency: #{self.name}"
+      loop do
+        self.last_dependency_check_time = Time.now
+        test_dependency
+        if satisfied?
+          puts "-> #{green_command}Dependency satisfied\n#{no_colour_command}"
+          break
+        else
+          puts "-> #{red_command}Dependency not satisfied:\n" + 
+            "#{errors}#{no_colour_command}"
+          wait_for_changes
+          puts "Rechecking dependency: #{self.name}"
+        end
+      end
+    end
+  end
+  
+  # Resets the dependency state so that it will recheck the dependency during
+  # the next test run regardless of whether any files have changed.
+  def reset
+    self.last_dependency_check_time = Time.at(0)
+  end
+  
+  private
+    
+    # Runs the dependency command redirecting stderr into stdout.
+    def test_dependency
+      @results = `#{self.command} 2>&1`
+    end
+    
+    # Returns true if the output of the dependency command matches the 
+    # #satisfied_regexp, false otherwise.
+    def satisfied?
+      (@results =~ self.satisfied_regexp) ? true : false
+    end
+    
+    # Returns a string of errors matching the #errors_regexp on separate lines
+    # indented by four spaces.
+    def errors
+      "    " + @results.scan(self.errors_regexp).join("\n    ")
+    end
+    
+    # Sleeps until files in the codebase are modified.
+    def wait_for_changes
+      sleep(self.autotest_instance.sleep) until find_changed_files
+    end
+    
+    # Searches the codebase for files that have been modified since the last
+    # dependency check.
+    def find_changed_files
+      changed_files = self.autotest_instance.
+        find_files.
+        delete_if do |filename, modification_time| 
+          modification_time < self.last_dependency_check_time
+        end
+        
+      changed_files.empty? ? false : true
+    end
+    
+    # Returns a string representing the colour code for green output if 
+    # output colorisation is turned on.
+    def green_command
+      self.class.colourise_output ? "\e\[32m" : nil
+    end
+    
+    # Returns a string representing the colour code for red output if 
+    # output colorisation is turned on.
+    def red_command
+      self.class.colourise_output ? "\e\[31m" : nil
+    end
+    
+    # Returns a string representing the colour code for colourless output if 
+    # output colorisation is turned on.
+    def no_colour_command
+      self.class.colourise_output ? "\e\[0m" : nil
+    end
+end

data/spec/autotest-run_dependencies_spec.rb

@@ -0,0 +1,349 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe Autotest::RunDependencies do
+  before(:each) do
+    @dependency_parameters = {
+      :name => 'Generic dependency',
+      :command => 'script_ensuring_dependency_is_in_place arg arg',
+      :satisfied_regexp => /success/,
+      :errors_regexp => /error: (.*)/
+    }
+    @dependency = Autotest::RunDependencies.new(@dependency_parameters)
+  end
+  
+  describe "#initialize" do
+    it "sets the dependency name to the supplied name" do
+      @dependency.name.should == @dependency_parameters[:name]
+    end
+
+    it "sets the dependency command to the supplied command" do
+      @dependency.command.should == @dependency_parameters[:command]
+    end
+    
+    it "sets the dependency satisfied_regexp to the supplied " + 
+      "satisfied_regexp" do
+      @dependency.satisfied_regexp.should == 
+        @dependency_parameters[:satisfied_regexp]
+    end
+    
+    it "sets the dependency errors_regexp to the supplied " + 
+      "errors_regexp" do
+      @dependency.errors_regexp.should ==
+        @dependency_parameters[:errors_regexp]
+    end
+    
+    it "sets the dependency last_dependency_check_time to the epoch" do
+      @dependency.last_dependency_check_time.should == Time.at(0)
+    end
+  end
+  
+  describe ".add" do
+    before(:each) do
+      Autotest.stub(:add_hook)
+    end
+    
+    it "creates a new dependecy with the parameters set in the block" do
+      Autotest::RunDependencies.should_receive(:new).with(
+        :name => 'Dependency name',
+        :command => 'dependency_command',
+        :satisfied_regexp => /satisfied/,
+        :errors_regexp => /error/
+      )
+      Autotest::RunDependencies.add do |dependency|
+        dependency.name = 'Dependency name'
+        dependency.command = 'dependency_command'
+        dependency.satisfied_regexp = /satisfied/
+        dependency.errors_regexp = /error/
+      end
+    end
+    
+    it "adds an :initialize hook to autotest in which the dependencies' " + 
+      "autotest instance is set" do
+      mock_dependency = mock('dependency', :null_object => true)
+      Autotest::RunDependencies.stub(:new).and_return(mock_dependency)
+
+      mock_dependency.should_receive(:autotest_instance=).with('autotest')
+      Autotest.
+        should_receive(:add_hook).
+        with(:initialize).
+        and_yield('autotest')
+
+      Autotest::RunDependencies.add do |dependency|
+        dependency.name = 'Dependency name'
+        dependency.command = 'dependency_command'
+        dependency.satisfied_regexp = /satisfied/
+        dependency.errors_regexp = /error/
+      end
+    end
+    
+    it "adds a :run_command hook to autotest in which the " + 
+      "ensure_dependency_is_satisfied method is called on the dependency" do
+      mock_dependency = mock('dependency', :null_object => true)
+      Autotest::RunDependencies.stub(:new).and_return(mock_dependency)
+      
+      mock_dependency.should_receive(:ensure_dependency_is_satisfied)
+      Autotest.
+        should_receive(:add_hook).
+        with(:run_command).
+        and_yield('autotest')
+      
+      Autotest::RunDependencies.add do |dependency|
+        dependency.name = 'Dependency name'
+        dependency.command = 'dependency_command'
+        dependency.satisfied_regexp = /satisfied/
+        dependency.errors_regexp = /error/
+      end
+    end
+    
+    it "adds an :interrupt hook to autotest in which the reset method is " + 
+      "called on the dependency" do
+      mock_dependency = mock('dependency', :null_object => true)
+      Autotest::RunDependencies.stub(:new).and_return(mock_dependency)
+      
+      mock_dependency.should_receive(:reset)
+      Autotest.
+        should_receive(:add_hook).
+        with(:interrupt).
+        and_yield('autotest')
+      
+      Autotest::RunDependencies.add do |dependency|
+        dependency.name = 'Dependency name'
+        dependency.command = 'dependency_command'
+        dependency.satisfied_regexp = /satisfied/
+        dependency.errors_regexp = /error/
+      end
+    end
+    
+    it "returns the created dependency" do
+      mock_dependency = mock('dependency', :null_object => true)
+      Autotest::RunDependencies.stub(:new).and_return(mock_dependency)
+      
+      Autotest::RunDependencies.add.should == mock_dependency
+    end
+  end
+  
+  describe "#ensure_dependency_is_satisfied" do
+    before(:each) do
+      @autotest = mock('autotest')
+      @autotest.stub(:sleep).and_return(1)
+      @dependency.stub(:`).and_return('success')
+      @dependency.stub(:puts).and_return('true')
+      @dependency.autotest_instance = @autotest
+    end
+    
+    it "raises a runtime error if no command is set" do
+      @dependency.command = nil
+      expect {
+        @dependency.ensure_dependency_is_satisfied
+      }.to raise_error(RuntimeError)
+    end
+    
+    it "raises a runtime error if no satisfied_regexp is set" do
+      @dependency.satisfied_regexp = nil
+      expect {
+        @dependency.ensure_dependency_is_satisfied
+      }.to raise_error(RuntimeError)
+    end
+    
+    describe "if files have been modified since the last dependency test" do
+      before(:each) do
+        @dependency.last_dependency_check_time = Time.at(0)
+        @autotest.stub(:find_files).and_return(
+          {'file1' => Time.at(10), 'file2' => Time.at(20)}
+        )
+      end
+      
+      it "calls the stored command, redirecting stderr to stdout" do
+        @dependency.should_receive(:`).with(@dependency.command + " 2>&1")
+        @dependency.ensure_dependency_is_satisfied
+      end
+      
+      it "outputs a message on a new line saying that it is about to " + 
+        "check the dependency" do
+        @dependency.should_receive(:puts).with(
+          "\nChecking dependency: #{@dependency.name}"
+        )
+        @dependency.ensure_dependency_is_satisfied
+      end
+      
+      describe "and the dependency is satisfied" do
+        it "outputs a message saying the dependency has been satisfied" do
+          @dependency.should_receive(:puts).with(
+            /Dependency satisfied/
+          )
+          @dependency.ensure_dependency_is_satisfied
+        end
+        
+        it "only calls the stored command once and returns" do
+          @dependency.should_receive(:`).once
+          @dependency.ensure_dependency_is_satisfied
+        end
+      end
+      
+      describe "and the dependency is not satisfied" do
+        before(:each) do
+          @dependency.stub(:`).and_return(
+            "failed:\nerror: dependency not met\nerror: sorry mate",
+            "success"
+          )
+          @autotest.stub(:find_files).and_return(
+            {'file1' => Time.at(10), 'file2' => Time.at(20)},
+            {'file1' => Time.now + 100, 'file2' => Time.at(20)}
+          )
+        end
+        
+        it "outputs a message saying the dependency hasn't been satisfied" do
+          @dependency.should_receive(:puts).with(
+            /Dependency not satisfied:/
+          )
+          @dependency.ensure_dependency_is_satisfied
+        end
+        
+        it "outputs any lines in the command result that match the error " +
+          "regexp on newlines and indented by a tab character" do
+          @dependency.should_receive(:puts).with(
+            /\s*dependency not met\n\s*sorry mate/
+          )
+          @dependency.ensure_dependency_is_satisfied
+        end
+        
+        it "sleeps until some files have a modification time more recent " + 
+          "than the last_dependency_check_time" do
+          @autotest.stub(:find_files).and_return(
+            {'file1' => Time.at(10), 'file2' => Time.at(20)},
+            {'file1' => Time.at(10), 'file2' => Time.at(20)},
+            {'file1' => Time.at(10), 'file2' => Time.at(20)},
+            {'file1' => (Time.now + 100), 'file2' => Time.at(20)}
+          )
+          @dependency.should_receive(:sleep).with(@autotest.sleep).twice
+          @dependency.ensure_dependency_is_satisfied
+        end
+        
+        it "outputs a message saying that it is rechecking the dependency " + 
+          "if a file is changed" do
+          @dependency.should_receive(:puts).with(
+            "Rechecking dependency: #{@dependency.name}"
+          )
+          @dependency.ensure_dependency_is_satisfied
+        end
+        
+        it "reruns the dependency check until it is successful" do
+          @autotest.stub(:find_files).and_return(
+            {'file1' => Time.at(10), 'file2' => Time.at(20)},
+            {'file1' => (Time.now + 100), 'file2' => Time.at(20)},
+            {'file1' => (Time.now + 100), 'file2' => (Time.now + 200)}
+          )
+          @dependency.should_receive(:`).exactly(3).times.and_return(
+            "failed:\nerror: dependency not met\nerror: sorry mate",
+            "failed:\nerror: dependency not met\nerror: sorry mate",
+            "success"
+          )
+          @dependency.ensure_dependency_is_satisfied
+        end
+      end
+    end    
+  end
+
+  describe "#reset" do
+    it "resets the last_dependency_check_time to the epoch" do
+      @dependency.last_dependency_check_time = Time.now
+      @dependency.reset
+      @dependency.last_dependency_check_time.should == Time.at(0)
+    end
+  end
+  
+  describe "colourised output" do
+    before(:each) do
+      @autotest = mock('autotest')
+      @autotest.stub(:sleep).and_return(1)
+      @autotest.stub(:find_files).and_return(
+        {'file1' => Time.at(10), 'file2' => Time.at(20)},
+        {'file1' => Time.now + 100, 'file2' => Time.at(20)}
+      )
+      @dependency.stub(:`).and_return('success')
+      @dependency.stub(:puts).and_return('true')
+      @dependency.autotest_instance = @autotest
+    end
+    
+    describe "#colourise_output" do
+      describe "by default" do
+        it "is true" do
+          Autotest::RunDependencies.colourise_output.should be_true
+        end
+      end
+    end
+
+    describe "#colourise_output=" do
+      it "allows colourised output to be turned off" do
+        Autotest::RunDependencies.colourise_output = false
+        Autotest::RunDependencies.colourise_output.should be_false
+      end
+    end
+    
+    describe "when on" do
+      before(:each) do
+        Autotest::RunDependencies.colourise_output = true
+      end
+      
+      it "outputs the dependency satisfied message in green" do
+        @dependency.should_receive(:puts).with(
+          /\e\[32mDependency satisfied\n\e\[0m/
+        )
+        @dependency.ensure_dependency_is_satisfied
+      end
+      
+      it "outputs the dependency not satisfied message and errors in red" do
+        @dependency.stub(:`).and_return(
+          "failed:\nerror: dependency not met\nerror: sorry mate",
+          "success"
+        )
+        @autotest.stub(:find_files).and_return(
+          {'file1' => Time.at(10), 'file2' => Time.at(20)},
+          {'file1' => Time.now + 100, 'file2' => Time.at(20)}
+        )
+        
+        @dependency.should_receive(:puts).with(
+          /\e\[31mDependency\snot\ssatisfied:\n
+            .*dependency\snot\smet.*\n
+            .*sorry\smate.*\e\[0m/x
+        )
+        
+        @dependency.ensure_dependency_is_satisfied
+      end
+    end
+    
+    describe "when off" do
+      before(:each) do
+        Autotest::RunDependencies.colourise_output = false
+      end
+      
+      it "outputs the dependency satisfied message with no colour commands" do
+        @dependency.should_receive(:puts).with(
+          "-> Dependency satisfied\n"
+        )
+        @dependency.ensure_dependency_is_satisfied
+      end
+      
+      it "outputs the dependency not satisfied message and errors with no " + 
+        "colour commands" do
+          @dependency.stub(:`).and_return(
+            "failed:\nerror: dependency not met\nerror: sorry mate",
+            "success"
+          )
+          @autotest.stub(:find_files).and_return(
+            {'file1' => Time.at(10), 'file2' => Time.at(20)},
+            {'file1' => Time.now + 100, 'file2' => Time.at(20)}
+          )
+
+          @dependency.should_receive(:puts).with(
+            "-> Dependency not satisfied:\n" + 
+            "    dependency not met\n" + 
+            "    sorry mate"
+          )
+
+          @dependency.ensure_dependency_is_satisfied
+      end
+    end
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(
+  File.join(File.dirname(__FILE__), '..', 'lib')
+) unless 
+  $:.include?(File.join(File.dirname(__FILE__), '..', 'lib')) || 
+  $:.include?(
+    File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+  )
+
+require 'autotest/run_dependencies'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: autotest-run_dependencies
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Toby Clemson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-06 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ZenTest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.9.0
+    version: 
+description: |
+  This gem provides a mechanism through which it is possible to specify that 
+  an arbitrary number of external dependencies are satisfied before a test 
+  run can be executed.
+  
+  Dependencies are added by specifying a name, command, satisfied_regexp and 
+  errors_regexp parameter for each. The command refers to a script that is 
+  run to satisfy or test the dependency. If the output of the command 
+  (either to standard output or standard error) matches the satisfied_regexp 
+  then the dependency is considered met otherwise any lines in the output 
+  matching errors_regexp are output and the dependency test waits for changes 
+  to the codebase before trying to satisfy the dependency again.
+
+email: tobyclemson@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/autotest-run_dependencies.rb
+- lib/autotest/run_dependencies.rb
+- spec/autotest-run_dependencies_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/tobyclemson/autotest-run_dependencies
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+- --main
+- README.rdoc
+- --title
+- Autotest::RunDependencies RDoc Documentation
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Test dependencies for autotest.
+test_files: 
+- spec/autotest-run_dependencies_spec.rb
+- spec/spec_helper.rb