guard-phpunit 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Maher Sallam
+
+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.md

@@ -0,0 +1,91 @@
+Guard::PHPUnit
+==============
+
+PHPUnit guard allows to automatically & intelligently launch tests when files
+are modified.
+
+Tested on MRI Ruby 1.8.7, 1.9.2 and 1.9.3.
+
+Install
+-------
+
+Please be sure to have [Ruby][1] running on your machine.
+The latest versions of Ruby come with a packages-manger called Gem. Gem can be used to
+install various packages, including PHPUnit guard.
+
+Before you continue, also make sure you have the [Guard][2] gem installed
+
+To install the PHPUnit gem, run the following command in the terminal:
+
+    gem install guard-phpunit
+
+Usage
+-----
+
+Please read the [Guard usage documentation][3].
+
+Guardfile
+---------
+
+Guard::PHPUnit can be used with any kind of PHP projects that uses PHPUnit as
+its testing framwork. Please read the [Guard documentation][3] for more information
+about the Guardfile DSL.
+
+By default, Guard::PHPUnit will use the current working directory (pwd) to
+search for tests and run them on start (if you enabled the `:all_on_start` option).
+
+### Example PHP project
+
+The [PHPUnit documentaion][4] uses the [Object Freezer][5] library as an example on how
+to organize tests. This project uses the `Tests` directory for its tests.
+
+An example of the Guardfile for the same project would look
+something like:
+
+```ruby
+guard 'phpunit', :tests_path => 'Tests', :cli => '--colors' do
+  # Watch tests files
+  watch(%r{^.+Test\.php$})
+
+  # Watch library files and run their tests
+  watch(%r{^Object/(.+)\.php}) { |m| "Tests/#{m[1]}Test.php" }
+end
+```
+
+Options
+-------
+
+The following options can be passed to Guard::PHPUnit:
+
+```ruby
+:all_on_start => false        # Run all tests on startup.
+                              # default: true
+
+:tests_path                   # Relative path to the tests directory. This path
+                              # is used when running all the tests.
+                              # default: the current working directory (pwd)
+
+:cli                          # The options passed to the phpunit command
+                              # when running the tests.
+                              # default: nil
+```
+
+Development
+-----------
+
+* Source hosted at [GitHub](https://github.com/Maher4Ever/guard-phpunit)
+* Report issues/Questions/Feature requests on [GitHub Issues](https://github.com/Maher4Ever/guard-phpunit/issues)
+
+Pull requests are very welcome! Make sure your patches are well tested. Please create a topic branch for every separate change
+you make.
+
+Author
+------
+
+[Maher Sallam](https://github.com/Maher4Ever)
+
+[1]:http://ruby-lang.org
+[2]:https://github.com/guard/guard
+[3]:https://github.com/guard/guard#readme
+[4]:http://www.phpunit.de/manual/current/en/
+[5]:https://github.com/sebastianbergmann/php-object-freezer/

data/lib/guard/phpunit/formatter.rb

@@ -0,0 +1,110 @@
+module Guard
+  class PHPUnit
+
+    # The Guard::PHPUnit formatter parses the output
+    # of phpunit which gets printed by the progress
+    # printer and formats the parsed results 
+    # for the notifier.
+    #
+    module Formatter
+      class << self
+
+        # Parses the tests output.
+        #
+        # @param [String] text the output of phpunit.
+        # @return [Hash] the parsed results
+        #
+        def parse_output(text)
+          results = {
+            :tests    => look_for_words_in('test',    text),
+            :failures => look_for_words_in('failure', text),
+            :errors   => look_for_words_in('error', text),
+            :pending  => look_for_words_in(['skipped', 'incomplete'], text),
+            :duration => look_for_duration_in(text)
+          }
+          results.freeze
+        end
+
+        # Outputs a system notification.
+        #
+        # @param [Hash] test_results the parsed tests results
+        # @option test_results [Integer] :tests tests count
+        # @option test_results [Integer] :failures failures count
+        # @option test_results [Integer] :errors count count
+        # @option test_results [Integer] :pending pending tests count
+        # @option test_results [Integer] :duration tests duration
+        #
+        def notify(test_results)
+          ::Guard::Notifier.notify(notifier_message(test_results), {
+            :title => 'PHPUnit results',
+            :image => notifier_image(test_results)
+          })
+        end
+
+        private
+
+        # Searches for a list of strings in the tests output
+        # and returns the total number assigned to these strings.
+        #
+        # @param [String, Array<String>] string_list the words
+        # @param [String] text the tests output
+        # @return [Integer] the total number assigned to the words 
+        #
+        def look_for_words_in(strings_list, text)
+          count = 0
+          strings_list = Array(strings_list)
+          strings_list.each do |s|
+            text =~ %r{
+              (\d+)   # count of what we are looking for 
+              [ ]     # then a space
+              #{s}s?  # then the string 
+              .*      # then whatever
+              \Z      # start looking at the end of the text
+            }x
+            count += $1.to_i unless $1.nil?
+          end
+          count
+        end
+
+        # Searches for the duration in the tests output
+        #
+        # @param [String] text the tests output
+        # @return [Integer] the duration
+        # 
+        def look_for_duration_in(text)
+          text =~ %r{Finished in (\d)+ seconds?.*\Z}m
+          $1.nil? ? 0 : $1.to_i
+        end
+
+        # Formats the message for the Notifier.
+        # 
+        # @param (see .notify)
+        # @return [String] the message
+        #
+        def notifier_message(results)
+          message = "#{results[:tests]} tests, #{results[:failures]} failures"
+          message << "\n#{results[:errors]} errors"    if results[:errors]  > 0
+          message << " (#{results[:pending]} pending)" if results[:pending] > 0
+          message << "\nin #{results[:duration]} seconds"
+          message
+        end
+
+        # Returns the appropriate image for the tests results
+        # 
+        # @param (see .notify)
+        # @return [Symbol] the image symbol
+        #
+        def notifier_image(results)
+          case
+          when results[:failures] + results[:errors] > 0
+            :failed
+          when results[:pending] > 0
+            :pending
+          else
+            :success
+          end
+        end
+      end
+    end
+  end
+end

data/lib/guard/phpunit/formatters/PHPUnit-Progress/PHPUnit/Extensions/Progress/ResultPrinter.php

@@ -0,0 +1,498 @@
+<?php
+
+/**
+ * Prints tests' results in a similar way
+ * to rspec's progress formatter.
+ *
+ * @package    PHPUnit
+ * @subpackage Progress
+ * @author     Maher Sallam <maher@sallam.me>
+ * @copyright  2011 Maher Sallam <maher@sallam.me>
+ * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
+ * @version    0.1
+ */
+class PHPUnit_Extensions_Progress_ResultPrinter extends PHPUnit_TextUI_ResultPrinter {
+
+  /**
+   * Constructor.
+   *
+   * @param  mixed   $out
+   * @param  boolean $verbose
+   * @param  boolean $colors
+   * @param  boolean $debug
+   */
+  public function __construct($out = NULL, $verbose = FALSE, $colors = FALSE, $debug = FALSE) {
+
+    // Start capturing output
+    ob_start();
+
+    $argv = $_SERVER['argv'];
+    $colors  = in_array('--colors', $argv) || $colors;
+    $verbose = in_array('--verbose', $argv) || in_array('-v', $argv) || $verbose;
+    $debug   = in_array('--debug', $argv) || $debug;
+
+    parent::__construct($out, $verbose, $colors, $debug);
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestResult $result
+   */
+  public function printResult(PHPUnit_Framework_TestResult $result)
+  {
+    print "\n";
+
+    if ($result->errorCount() > 0) {
+      $this->printErrors($result);
+    }
+
+    if ($result->failureCount() > 0) {
+      $this->printFailures($result);
+    }
+
+    if ($this->verbose) {
+      if ($result->deprecatedFeaturesCount() > 0) {
+        if ($result->failureCount() > 0) {
+          print "\n--\n\nDeprecated PHPUnit features are being used";
+        }
+
+        foreach ($result->deprecatedFeatures() as $deprecatedFeature) {
+          $this->write($deprecatedFeature . "\n\n");
+        }
+      }
+
+      if ($result->notImplementedCount() > 0) {
+        $this->printIncompletes($result);
+      }
+
+      if ($result->skippedCount() > 0) {
+        $this->printSkipped($result);
+      }
+    }
+
+    $this->printFooter($result);
+  } 
+
+  /**
+   * @param  array   $defects
+   * @param  integer $count
+   * @param  string  $type
+   */
+  protected function printDefects(array $defects, $count, $type)
+  {
+    if ($count == 0) {
+      return;
+    }
+
+    $this->write("\n" . $type . ":\n");
+
+    $i = 1;
+    $failOrError = $type == 'Failures' || $type == 'Errors';
+
+    foreach ($defects as $defect) {
+      $this->printDefect($defect, $i++, $failOrError);
+      $this->write("\n");
+    }
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestFailure $defect
+   * @param  integer                       $count
+   * @param  boolean                       $failOrError
+   */
+  protected function printDefect(PHPUnit_Framework_TestFailure $defect, $count, $failOrError = true)
+  {
+    $this->printDefectHeader($defect, $count, $failOrError);
+
+    $padding = str_repeat(' ', 
+      4 + ( $failOrError ? strlen((string)$count) : 0 )
+    );
+
+    $this->printDefectBody($defect, $count, $failOrError, $padding);
+    $this->printDefectTrace($defect, $padding);
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestFailure $defect
+   * @param  integer                       $count
+   * @param  boolean                       $failOrError
+   */
+  protected function printDefectHeader(PHPUnit_Framework_TestFailure $defect, $count, $failOrError = true)
+  {
+    $failedTest = $defect->failedTest();
+
+    if ($failedTest instanceof PHPUnit_Framework_SelfDescribing) {
+      $testName = $failedTest->toString();
+    } else {
+      $testName = get_class($failedTest);
+    }
+
+    if ( $failOrError ) {
+      $this->write(
+        sprintf(
+          "\n  %d) %s",
+
+          $count,
+          $testName
+        )
+      );
+    } else {
+      $this->write( 
+        sprintf( "  %s", $this->yellow($testName) )
+      ); 
+    }
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestFailure $defect
+   * @param  integer                       $count
+   * @param  boolean                       $failOrError
+   * @param  string                        $padding
+   */
+  protected function printDefectBody(PHPUnit_Framework_TestFailure $defect, $count, $failOrError, $padding)
+  {
+    $error = trim($defect->getExceptionAsString());
+
+    if ( !empty($error) ) {
+      $error = explode("\n", $error);
+      $error = "\n" . $padding . implode("\n  " . $padding , $error);
+
+      $this->write( $failOrError ? $this->red($error) : $this->cyan($error) );
+    }
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestFailure $defect
+   * @param  string                        $padding
+   */
+  protected function printDefectTrace(PHPUnit_Framework_TestFailure $defect, $padding = 0)
+  { 
+    $trace = trim(
+      PHPUnit_Util_Filter::getFilteredStacktrace(
+        $defect->thrownException()
+      )
+    );
+
+    if ( ! empty($trace) ) {
+      $trace = explode("\n", $trace);
+      $trace = "\n" . $padding . '# ' . implode("\n${padding}# ", $trace);
+
+      $this->write($this->cyan($trace));
+    }
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestResult  $result
+   */
+  protected function printErrors(PHPUnit_Framework_TestResult $result)
+  {
+    $this->printDefects(
+      $result->errors(),
+      $result->errorCount(), 
+      'Errors'
+    );
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestResult  $result
+   */
+  protected function printFailures(PHPUnit_Framework_TestResult $result)
+  {
+    $this->printDefects(
+      $result->failures(),
+      $result->failureCount(),
+      'Failures'
+    );
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestResult  $result
+   */
+  protected function printIncompletes(PHPUnit_Framework_TestResult $result)
+  {
+    $this->printDefects(
+      $result->notImplemented(),
+      $result->notImplementedCount(),
+      'Incomplete tests'
+    );
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestResult  $result
+   * @since  Method available since Release 3.0.0
+   */
+  protected function printSkipped(PHPUnit_Framework_TestResult $result)
+  {
+    $this->printDefects(
+      $result->skipped(),
+      $result->skippedCount(),
+      'Skipped tests'
+    );
+  }
+
+  /**
+   * @param  PHPUnit_Framework_TestResult  $result
+   */
+  protected function printFooter(PHPUnit_Framework_TestResult $result)
+  {
+
+    $this->write( sprintf("\nFinished in %s\n", PHP_Timer::timeSinceStartOfRequest()) );
+
+    $resultsCount = count($result);
+
+    $footer = sprintf("%d test%s, %d assertion%s",
+      $resultsCount,
+      $resultsCount == 1 ? '' : 's',
+      $this->numAssertions,
+      $this->numAssertions == 1 ? '' : 's' 
+    );
+
+    if ( $result->wasSuccessful() &&
+      $result->allCompletlyImplemented() &&
+      $result->noneSkipped() )
+    {
+      $this->write($this->green($footer));
+    }
+
+    else if ( ( !$result->allCompletlyImplemented() || !$result->noneSkipped() ) 
+      &&
+      $result->wasSuccessful() ) 
+    {
+
+      $footer .= sprintf(
+        "%s%s",
+
+        $this->getCountString(
+          $result->notImplementedCount(), 'incomplete'
+        ),
+        $this->getCountString(
+          $result->skippedCount(), 'skipped'
+        )
+      );
+
+      $this->write($this->yellow($footer));
+
+    }
+
+    else {
+
+      $footer .= sprintf(
+        "%s%s%s%s",
+
+        $this->getCountString($result->failureCount(), 'failures'),
+        $this->getCountString($result->errorCount(), 'errors'),
+        $this->getCountString(
+          $result->notImplementedCount(), 'incomplete'
+        ),
+        $this->getCountString($result->skippedCount(), 'skipped')
+      );
+
+      $footer  = preg_replace('/,$/', '', $footer);
+
+      $this->write($this->red($footer));
+    }
+
+    if ( ! $this->verbose &&
+      $result->deprecatedFeaturesCount() > 0 ) 
+    {
+      $message = sprintf(
+        "Warning: Deprecated PHPUnit features are being used %s times!\n".
+        "Use --verbose for more information.\n",
+        $result->deprecatedFeaturesCount()
+      );
+
+      if ($this->colors) {
+        $message = "\x1b[37;41m\x1b[2K" . $message .
+          "\x1b[0m";
+      }
+
+      $this->write("\n" . $message);
+    }
+
+    $this->writeNewLine();
+  }
+
+  /**
+   * @param  integer $count
+   * @param  string  $name
+   * @return string
+   * @since  Method available since Release 3.0.0
+   */
+  protected function getCountString($count, $name)
+  {
+    $string = '';
+
+    if ($count > 0) {
+      $string = sprintf(
+        ', %d %s',
+
+        $count,
+        $name
+      );
+    }
+
+    return $string;
+  }
+
+  /**
+   * An error occurred.
+   *
+   * @param  PHPUnit_Framework_Test $test
+   * @param  Exception              $e
+   * @param  float                  $time
+   */
+  public function addError(PHPUnit_Framework_Test $test, Exception $e, $time)
+  {
+    $this->writeProgress($this->red('E'));
+    $this->lastTestFailed = TRUE;
+  }
+
+  /**
+   * A failure occurred.
+   *
+   * @param  PHPUnit_Framework_Test                 $test
+   * @param  PHPUnit_Framework_AssertionFailedError $e
+   * @param  float                                  $time
+   */
+  public function addFailure(PHPUnit_Framework_Test $test, PHPUnit_Framework_AssertionFailedError $e, $time)
+  {
+    $this->writeProgress($this->red('F'));
+    $this->lastTestFailed = TRUE;
+  }
+
+  /**
+   * Incomplete test.
+   *
+   * @param  PHPUnit_Framework_Test $test
+   * @param  Exception              $e
+   * @param  float                  $time
+   */
+  public function addIncompleteTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+  {
+    $this->writeProgress($this->yellow('I'));
+    $this->lastTestFailed = TRUE;
+  }
+
+  /**
+   * Skipped test.
+   *
+   * @param  PHPUnit_Framework_Test $test
+   * @param  Exception              $e
+   * @param  float                  $time
+   * @since  Method available since Release 3.0.0
+   */
+  public function addSkippedTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+  {
+    $this->writeProgress($this->yellow('S'));
+    $this->lastTestFailed = TRUE;
+  }
+
+  /**
+   * A test ended.
+   *
+   * @param  PHPUnit_Framework_Test $test
+   * @param  float                  $time
+   */
+  public function endTest(PHPUnit_Framework_Test $test, $time)
+  {
+    if (!$this->lastTestFailed) {
+      $this->writeProgress($this->green('.'));
+    }
+
+    if ($test instanceof PHPUnit_Framework_TestCase) {
+      $this->numAssertions += $test->getNumAssertions();
+    }
+
+    else if ($test instanceof PHPUnit_Extensions_PhptTestCase) {
+      $this->numAssertions++;
+    }
+
+    $this->lastTestFailed = FALSE;
+
+    if ($this->verbose && $test instanceof PHPUnit_Framework_TestCase) {
+      $this->write($test->getActualOutput());
+    }
+
+  }
+
+  /**
+   * @param  string $progress
+   */
+  protected function writeProgress($progress)
+  {
+    static $deletedHeader = false;
+
+    if ( ! $deletedHeader ) {
+      ob_clean();
+      $deletedHeader = true;
+    }
+
+    parent::writeProgress($progress);
+  }
+
+  /**
+   * Returns a colored string which can be used
+   * in the terminal.
+   *
+   * @param string  $text
+   * @param integer $color_code
+   */
+  protected function color($text, $color_code) {
+    return $this->colors ? "\033[${color_code}m" . $text . "\033[0m" : $text;
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function bold($text) {
+    return $this->color($text, "1");
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function red($text) {
+    return $this->color($text, "31");
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function green($text) {
+    return $this->color($text, "32");
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function yellow($text) {
+    return $this->color($text, "33");
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function blue($text) {
+    return $this->color($text, "34");
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function magenta($text) {
+    return $this->color($text, "35");
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function cyan($text) {
+    return $this->color($text, "36");
+  }
+
+  /**
+   * @param string $text
+   */
+  protected function white($text) {
+    return $this->color($text, "37");
+  }
+}

data/lib/guard/phpunit/inspector.rb

@@ -0,0 +1,54 @@
+module Guard
+  class PHPUnit
+
+    # The Guard::PHPUnit inspector verfies that the changed paths
+    # are valid for Guard::PHPUnit.
+    #
+    module Inspector
+      class << self
+
+        attr_accessor :tests_path
+
+        # Clean the changed paths and return only valid
+        # PHPUnit tests files.
+        #
+        # @param [Array<String>] paths the changed paths
+        # @return [Array<String>] the valid tests files
+        #
+        def clean(paths)
+          paths.uniq!
+          paths.compact!
+          paths = paths.select { |p| test_file?(p) }
+          clear_tests_files_list
+          paths
+        end
+
+        private
+
+        # Checks if the paths is a valid test file.
+        #
+        # @param [String] path the test path
+        # @return [Boolean] whether the path a valid test or not
+        #
+        def test_file?(path)
+          tests_files.include?(path)
+        end
+
+        # Scans the tests path and keeps a list of all
+        # tests paths.
+        #
+        def tests_files
+          @tests_files ||= Dir.glob( File.join(tests_path, '**', '*Test.php') )
+        end
+
+        # Clears the list of PHPUnit tests.
+        #
+        # @see #clean
+        #
+        def clear_tests_files_list
+          @tests_files = nil
+        end
+      end
+    end
+  end
+end

data/lib/guard/phpunit/runner.rb

@@ -0,0 +1,170 @@
+require 'tmpdir'
+require 'fileutils'
+
+module Guard
+  class PHPUnit
+
+    # The Guard::PHPUnit runner handles running the tests, displaying
+    # their output and notifying the user about the results.
+    #
+    module Runner
+      class << self
+
+        PHPUNIT_ERRORS_EXITCODE = 2
+
+        # Runs the PHPUnit tests and displays notifications
+        # about the results.
+        #
+        # @param [Array<Strings>] path to the tests files.
+        # @param (see PHPUnit#initialize) 
+        # @return [Boolean] whether the tests were run successfully
+        #
+        def run(paths, options = {})
+          paths = Array(paths)
+          return false if paths.empty?
+
+          notify_start(paths, options)
+          output  = run_tests(paths, options)
+          
+          print_output output
+
+          # return false in case the system call fails with no status!
+          return false if $?.nil?
+
+          if $?.success? or tests_contain_errors?
+            notify_results(output, options)
+          else
+            notify_failure(options) 
+          end
+
+          $?.success?
+        end
+
+        private
+
+        # Displays the start testing notification.
+        #
+        # @param (see #run)
+        # @param (see #run)
+        #
+        def notify_start(paths, options)
+          message = options[:message] || "Running: #{paths.join(' ')}"
+          UI.info(message, :reset => true)
+        end
+
+        # Executes the testing commandon the tests 
+        # and returns the output.
+        #
+        # @param (see #run)
+        # @param (see #run)
+        #
+        def run_tests(paths, options)
+          if paths.length == 1
+            tests_path = paths.first
+            output = execute_command phpunit_command(tests_path, options)
+          else
+            create_tests_folder_for(paths) do |tests_folder|
+              output = execute_command phpunit_command(tests_folder, options)
+            end
+          end
+          output
+        end
+
+        # Prints the tests output to the terminal.
+        #
+        # @param [String] output the tests output
+        #
+        def print_output(output)
+          UI.info output
+        end
+
+        # Displays a notification about the tests results.
+        #
+        # @param [String] output the tests output
+        # @param (see #run)
+        #
+        def notify_results(output, options)
+          return if options[:notification] == false
+          results = Formatter.parse_output(output)
+          Formatter.notify(results)
+        end
+
+        # Displays a notification about failing to run the tests
+        #
+        # @param (see #run)
+        #
+        def notify_failure(options)
+          return if options[:notification] == false
+          ::Guard::Notifier.notify('Failed! Check the console', :title => 'PHPUnit results', :image => :failed)
+        end
+
+        # Checks the exitstatus of the phpunit command
+        # for a sign of errors in the tests.
+        #
+        # @return [Boolean] whether the tests contain errors or not
+        #
+        def tests_contain_errors?
+          $?.exitstatus == PHPUNIT_ERRORS_EXITCODE
+        end
+
+        # Creates a temporary folder which has links to
+        # the tests paths. This method is used because PHPUnit
+        # can't run multiple tests files at the same time and generate
+        # one result for them.
+        #
+        # @param (see #run)
+        # @yield [String] d the temporary dir for the tests
+        #
+        def create_tests_folder_for(paths)
+          Dir.mktmpdir('guard_phpunit') do |d|
+            symlink_paths_to_tests_folder(paths, d)
+            yield d
+          end
+        end
+
+        # Creates symbolic links inside the folder pointing 
+        # back to the paths.
+        #
+        # @see #create_tests_folder_for
+        #
+        # @param (see #run)
+        # @param [String] the folder in which the links must be made
+        #
+        def symlink_paths_to_tests_folder(paths, folder)
+          paths.each do |p|
+            FileUtils.mkdir_p( File.join(folder, File.dirname(p) ) ) unless File.dirname(p) == '.'
+            FileUtils.ln_s(Pathname.new(p).realpath, File.join(folder, p))
+          end
+        end
+
+        # Generates the phpunit command for the tests paths.
+        # 
+        # @param (see #run)
+        # @param (see #run)
+        # @see #run_tests
+        # 
+        def phpunit_command(path, options)
+          formatter_path = File.join( File.dirname(__FILE__), 'formatters', 'PHPUnit-Progress')
+
+          cmd_parts = []
+          cmd_parts << "phpunit"
+          cmd_parts << "--include-path #{formatter_path}"
+          cmd_parts << "--printer PHPUnit_Extensions_Progress_ResultPrinter"
+          cmd_parts << options[:cli] if options[:cli]
+          cmd_parts << path
+
+          cmd_parts.join(' ')
+        end
+
+        # Executes a system command and returns the output.
+        #
+        # @param [String] command the command to be run
+        # @return [String] the output of the executed command
+        #
+        def execute_command(command)
+          %x{#{command}}
+        end
+      end
+    end
+  end
+end

data/lib/guard/phpunit/templates/Guardfile

@@ -0,0 +1,3 @@
+guard 'phpunit', :cli => '--colors' do
+  watch(%r{^.+Test\.php$})
+end

data/lib/guard/phpunit/version.rb

@@ -0,0 +1,6 @@
+module Guard
+  # Guard::PHPUnitVersion is used in the gem specification.
+  module PHPUnitVersion
+    VERSION = "0.0.1"
+  end
+end

data/lib/guard/phpunit.rb

@@ -0,0 +1,64 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+
+  # The PHPUnit guard gets notified about system 
+  # events.
+  #
+  class PHPUnit < Guard
+
+    autoload :Inspector, 'guard/phpunit/inspector'
+    autoload :Formatter, 'guard/phpunit/formatter'
+    autoload :Runner,    'guard/phpunit/runner'
+
+    DEFAULT_OPTIONS = {
+      :all_on_start => true,
+      :tests_path   => Dir.pwd
+    }
+
+    # Initialize Guard::PHPUnit.
+    #
+    # @param [Array<Guard::Watcher>] watchers the watchers in the Guard block
+    # @param [Hash] options the options for the Guard
+    # @option options [Boolean] :all_on_start run all tests on start
+    # @option options [String] :cli The CLI arguments passed to phpunit
+    # @option options [String] :tests_path the path where all tests exist
+    #
+    def initialize(watchers = [], options = {})
+      defaults = DEFAULT_OPTIONS.clone
+      @options = defaults.merge(options)
+      super(watchers, @options)
+      Inspector.tests_path = @options[:tests_path]
+    end
+
+    # Gets called once when Guard starts.
+    #
+    # @raise [:task_has_failed] when stop has failed
+    #
+    def start
+      run_all if options[:all_on_start]
+    end
+
+    # Gets called when all tests should be run.
+    #
+    # @raise (see #start)
+    #
+    def run_all
+      success = Runner.run(options[:tests_path], options.merge(
+        :message => 'Running all tests'
+      ))
+      throw :task_has_failed unless success
+    end
+
+    # Gets called when the watched tests have changes.
+    #
+    # @param [Array<String>] paths to the changed tests
+    # @raise (see #start)
+    #
+    def run_on_change(paths)
+      success = Runner.run(paths, options)
+      throw :task_has_failed unless success
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: guard-phpunit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Maher Sallam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &13084420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *13084420
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &13083340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *13083340
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &13082360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: *13082360
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &13081360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: *13081360
+description: Guard::PHPUnit automatically run your unit-tests written with the PHPUnit
+  testing framework.
+email:
+- maher@sallam.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/guard/phpunit.rb
+- lib/guard/phpunit/formatter.rb
+- lib/guard/phpunit/inspector.rb
+- lib/guard/phpunit/runner.rb
+- lib/guard/phpunit/templates/Guardfile
+- lib/guard/phpunit/version.rb
+- lib/guard/phpunit/formatters/PHPUnit-Progress/PHPUnit/Extensions/Progress/ResultPrinter.php
+- LICENSE
+- README.md
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: guard-phpunit
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Guard gem for PHPUnit
+test_files: []
+has_rdoc: