GlobalFunctionFile.php 0000664 00000001643 15152054720 0010772 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class GlobalFunctionFile extends FactoryFile
{
/**
* @var string containing function definitions
*/
private $functions;
public function __construct($file)
{
parent::__construct($file, ' ');
$this->functions = '';
}
public function addCall(FactoryCall $call)
{
$this->functions .= PHP_EOL . $this->generateFactoryCall($call);
}
public function build()
{
$this->addFileHeader();
$this->addPart('functions_imports');
$this->addPart('functions_header');
$this->addCode($this->functions);
$this->addPart('functions_footer');
}
public function generateFactoryCall(FactoryCall $call)
{
$code = "if (!function_exists('{$call->getName()}')) {";
$code.= parent::generateFactoryCall($call);
$code.= "}\n";
return $code;
}
}
FactoryFile.php 0000664 00000006034 15152054720 0007472 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
abstract class FactoryFile
{
/**
* Hamcrest standard is two spaces for each level of indentation.
*
* @var string
*/
const INDENT = ' ';
private $indent;
private $file;
private $code;
public function __construct($file, $indent)
{
$this->file = $file;
$this->indent = $indent;
}
abstract public function addCall(FactoryCall $call);
abstract public function build();
public function addFileHeader()
{
$this->code = '';
$this->addPart('file_header');
}
public function addPart($name)
{
$this->addCode($this->readPart($name));
}
public function addCode($code)
{
$this->code .= $code;
}
public function readPart($name)
{
return file_get_contents(__DIR__ . "/parts/$name.txt");
}
public function generateFactoryCall(FactoryCall $call)
{
$method = $call->getMethod();
$code = $method->getComment($this->indent) . PHP_EOL;
$code .= $this->generateDeclaration($call->getName(), $method);
// $code .= $this->generateImport($method);
$code .= $this->generateCall($method);
$code .= $this->generateClosing();
return $code;
}
public function generateDeclaration($name, FactoryMethod $method)
{
$code = $this->indent . $this->getDeclarationModifiers()
. 'function ' . $name . '('
. $this->generateDeclarationArguments($method)
. ')' . PHP_EOL . $this->indent . '{' . PHP_EOL;
return $code;
}
public function getDeclarationModifiers()
{
return '';
}
public function generateDeclarationArguments(FactoryMethod $method)
{
if ($method->acceptsVariableArguments()) {
return '/* args... */';
} else {
return $method->getParameterDeclarations();
}
}
public function generateImport(FactoryMethod $method)
{
return $this->indent . self::INDENT . "require_once '" . $method->getClass()->getFile() . "';" . PHP_EOL;
}
public function generateCall(FactoryMethod $method)
{
$code = '';
if ($method->acceptsVariableArguments()) {
$code .= $this->indent . self::INDENT . '$args = func_get_args();' . PHP_EOL;
}
$code .= $this->indent . self::INDENT . 'return ';
if ($method->acceptsVariableArguments()) {
$code .= 'call_user_func_array(array(\''
. '\\' . $method->getClassName() . '\', \''
. $method->getName() . '\'), $args);' . PHP_EOL;
} else {
$code .= '\\' . $method->getClassName() . '::'
. $method->getName() . '('
. $method->getParameterInvocations() . ');' . PHP_EOL;
}
return $code;
}
public function generateClosing()
{
return $this->indent . '}' . PHP_EOL;
}
public function write()
{
file_put_contents($this->file, $this->code);
}
}
run.php 0000664 00000002073 15152054720 0006066 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
require __DIR__ . '/../vendor/autoload.php';
/*
* Generates the Hamcrest\Matchers factory class and factory functions
* from the @factory doctags in the various matchers.
*/
define('GENERATOR_BASE', __DIR__);
define('HAMCREST_BASE', realpath(dirname(GENERATOR_BASE) . DIRECTORY_SEPARATOR . 'hamcrest'));
define('GLOBAL_FUNCTIONS_FILE', HAMCREST_BASE . DIRECTORY_SEPARATOR . 'Hamcrest.php');
define('STATIC_MATCHERS_FILE', HAMCREST_BASE . DIRECTORY_SEPARATOR . 'Hamcrest' . DIRECTORY_SEPARATOR . 'Matchers.php');
set_include_path(
implode(
PATH_SEPARATOR,
array(
GENERATOR_BASE,
HAMCREST_BASE,
get_include_path()
)
)
);
@unlink(GLOBAL_FUNCTIONS_FILE);
@unlink(STATIC_MATCHERS_FILE);
$generator = new FactoryGenerator(HAMCREST_BASE . DIRECTORY_SEPARATOR . 'Hamcrest');
$generator->addFactoryFile(new StaticMethodFile(STATIC_MATCHERS_FILE));
$generator->addFactoryFile(new GlobalFunctionFile(GLOBAL_FUNCTIONS_FILE));
$generator->generate();
$generator->write();
FactoryCall.php 0000664 00000001143 15152054720 0007462 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class FactoryCall
{
/**
* Hamcrest standard is two spaces for each level of indentation.
*
* @var string
*/
const INDENT = ' ';
/**
* @var FactoryMethod
*/
private $method;
/**
* @var string
*/
private $name;
public function __construct(FactoryMethod $method, $name)
{
$this->method = $method;
$this->name = $name;
}
public function getMethod()
{
return $this->method;
}
public function getName()
{
return $this->name;
}
}
FactoryGenerator.php 0000664 00000005267 15152054720 0010550 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Controls the process of extracting @factory doctags
* and generating factory method files.
*
* Uses File_Iterator to scan for PHP files.
*/
class FactoryGenerator
{
/**
* Path to the Hamcrest PHP files to process.
*
* @var string
*/
private $path;
/**
* @var array of FactoryFile
*/
private $factoryFiles;
public function __construct($path)
{
$this->path = $path;
$this->factoryFiles = array();
}
public function addFactoryFile(FactoryFile $factoryFile)
{
$this->factoryFiles[] = $factoryFile;
}
public function generate()
{
$classes = $this->getClassesWithFactoryMethods();
foreach ($classes as $class) {
foreach ($class->getMethods() as $method) {
foreach ($method->getCalls() as $call) {
foreach ($this->factoryFiles as $file) {
$file->addCall($call);
}
}
}
}
}
public function write()
{
foreach ($this->factoryFiles as $file) {
$file->build();
$file->write();
}
}
public function getClassesWithFactoryMethods()
{
$classes = array();
$files = $this->getSortedFiles();
foreach ($files as $file) {
$class = $this->getFactoryClass($file);
if ($class !== null) {
$classes[] = $class;
}
}
return $classes;
}
public function getSortedFiles()
{
$iter = \File_Iterator_Factory::getFileIterator($this->path, '.php');
$files = array();
foreach ($iter as $file) {
$files[] = $file;
}
sort($files, SORT_STRING);
return $files;
}
public function getFactoryClass($file)
{
$name = $this->getFactoryClassName($file);
if ($name !== null) {
require_once $file;
if (class_exists($name)) {
$class = new FactoryClass(substr($file, strpos($file, 'Hamcrest/')), new ReflectionClass($name));
if ($class->isFactory()) {
return $class;
}
}
}
return null;
}
public function getFactoryClassName($file)
{
$content = file_get_contents($file);
if (preg_match('/namespace\s+(.+);/', $content, $namespace)
&& preg_match('/\n\s*class\s+(\w+)\s+extends\b/', $content, $className)
&& preg_match('/@factory\b/', $content)
) {
return $namespace[1] . '\\' . $className[1];
}
return null;
}
}
parts/matchers_imports.txt 0000664 00000000024 15152054720 0012020 0 ustar 00
namespace Hamcrest; parts/functions_footer.txt 0000664 00000000000 15152054720 0012015 0 ustar 00 parts/functions_imports.txt 0000664 00000000000 15152054720 0012214 0 ustar 00 parts/file_header.txt 0000664 00000000170 15152054720 0010666 0 ustar 00 <?php
/*
Copyright (c) 2009-2010 hamcrest.org
*/
// This file is generated from the static method @factory doctags.
parts/matchers_header.txt 0000664 00000000126 15152054720 0011556 0 ustar 00
/**
* A series of static factories for all hamcrest matchers.
*/
class Matchers
{
parts/matchers_footer.txt 0000664 00000000002 15152054720 0011615 0 ustar 00 }
parts/functions_header.txt 0000664 00000001216 15152054720 0011761 0 ustar 00
if (!function_exists('assertThat')) {
/**
* Make an assertion and throw {@link Hamcrest_AssertionError} if it fails.
*
* Example:
* <pre>
* //With an identifier
* assertThat("assertion identifier", $apple->flavour(), equalTo("tasty"));
* //Without an identifier
* assertThat($apple->flavour(), equalTo("tasty"));
* //Evaluating a boolean expression
* assertThat("some error", $a > $b);
* </pre>
*/
function assertThat()
{
$args = func_get_args();
call_user_func_array(
array('Hamcrest\MatcherAssert', 'assertThat'),
$args
);
}
}
FactoryParameter.php 0000664 00000003357 15152054720 0010540 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class FactoryParameter
{
/**
* @var FactoryMethod
*/
private $method;
/**
* @var ReflectionParameter
*/
private $reflector;
public function __construct(FactoryMethod $method, ReflectionParameter $reflector)
{
$this->method = $method;
$this->reflector = $reflector;
}
public function getDeclaration()
{
if ($this->reflector->isArray()) {
$code = 'array ';
} else {
$class = $this->reflector->getClass();
if ($class !== null) {
$code = '\\' . $class->name . ' ';
} else {
$code = '';
}
}
$code .= '$' . $this->reflector->name;
if ($this->reflector->isOptional()) {
$default = $this->reflector->getDefaultValue();
if (is_null($default)) {
$default = 'null';
} elseif (is_bool($default)) {
$default = $default ? 'true' : 'false';
} elseif (is_string($default)) {
$default = "'" . $default . "'";
} elseif (is_numeric($default)) {
$default = strval($default);
} elseif (is_array($default)) {
$default = 'array()';
} else {
echo 'Warning: unknown default type for ' . $this->getMethod()->getFullName() . PHP_EOL;
var_dump($default);
$default = 'null';
}
$code .= ' = ' . $default;
}
return $code;
}
public function getInvocation()
{
return '$' . $this->reflector->name;
}
public function getMethod()
{
return $this->method;
}
}
FactoryMethod.php 0000664 00000013025 15152054720 0010031 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Represents a single static factory method from a {@link Matcher} class.
*
* @todo Search method in file contents for func_get_args() to replace factoryVarArgs.
*/
class FactoryMethod
{
/**
* @var FactoryClass
*/
private $class;
/**
* @var ReflectionMethod
*/
private $reflector;
/**
* @var array of string
*/
private $comment;
/**
* @var bool
*/
private $isVarArgs;
/**
* @var array of FactoryCall
*/
private $calls;
/**
* @var array FactoryParameter
*/
private $parameters;
public function __construct(FactoryClass $class, ReflectionMethod $reflector)
{
$this->class = $class;
$this->reflector = $reflector;
$this->extractCommentWithoutLeadingShashesAndStars();
$this->extractFactoryNamesFromComment();
$this->extractParameters();
}
public function extractCommentWithoutLeadingShashesAndStars()
{
$this->comment = explode("\n", $this->reflector->getDocComment());
foreach ($this->comment as &$line) {
$line = preg_replace('#^\s*(/\\*+|\\*+/|\\*)\s?#', '', $line);
}
$this->trimLeadingBlankLinesFromComment();
$this->trimTrailingBlankLinesFromComment();
}
public function trimLeadingBlankLinesFromComment()
{
while (count($this->comment) > 0) {
$line = array_shift($this->comment);
if (trim($line) != '') {
array_unshift($this->comment, $line);
break;
}
}
}
public function trimTrailingBlankLinesFromComment()
{
while (count($this->comment) > 0) {
$line = array_pop($this->comment);
if (trim($line) != '') {
array_push($this->comment, $line);
break;
}
}
}
public function extractFactoryNamesFromComment()
{
$this->calls = array();
for ($i = 0; $i < count($this->comment); $i++) {
if ($this->extractFactoryNamesFromLine($this->comment[$i])) {
unset($this->comment[$i]);
}
}
$this->trimTrailingBlankLinesFromComment();
}
public function extractFactoryNamesFromLine($line)
{
if (preg_match('/^\s*@factory(\s+(.+))?$/', $line, $match)) {
$this->createCalls(
$this->extractFactoryNamesFromAnnotation(
isset($match[2]) ? trim($match[2]) : null
)
);
return true;
}
return false;
}
public function extractFactoryNamesFromAnnotation($value)
{
$primaryName = $this->reflector->getName();
if (empty($value)) {
return array($primaryName);
}
preg_match_all('/(\.{3}|-|[a-zA-Z_][a-zA-Z_0-9]*)/', $value, $match);
$names = $match[0];
if (in_array('...', $names)) {
$this->isVarArgs = true;
}
if (!in_array('-', $names) && !in_array($primaryName, $names)) {
array_unshift($names, $primaryName);
}
return $names;
}
public function createCalls(array $names)
{
$names = array_unique($names);
foreach ($names as $name) {
if ($name != '-' && $name != '...') {
$this->calls[] = new FactoryCall($this, $name);
}
}
}
public function extractParameters()
{
$this->parameters = array();
if (!$this->isVarArgs) {
foreach ($this->reflector->getParameters() as $parameter) {
$this->parameters[] = new FactoryParameter($this, $parameter);
}
}
}
public function getParameterDeclarations()
{
if ($this->isVarArgs || !$this->hasParameters()) {
return '';
}
$params = array();
foreach ($this->parameters as /** @var $parameter FactoryParameter */
$parameter) {
$params[] = $parameter->getDeclaration();
}
return implode(', ', $params);
}
public function getParameterInvocations()
{
if ($this->isVarArgs) {
return '';
}
$params = array();
foreach ($this->parameters as $parameter) {
$params[] = $parameter->getInvocation();
}
return implode(', ', $params);
}
public function getClass()
{
return $this->class;
}
public function getClassName()
{
return $this->class->getName();
}
public function getName()
{
return $this->reflector->name;
}
public function isFactory()
{
return count($this->calls) > 0;
}
public function getCalls()
{
return $this->calls;
}
public function acceptsVariableArguments()
{
return $this->isVarArgs;
}
public function hasParameters()
{
return !empty($this->parameters);
}
public function getParameters()
{
return $this->parameters;
}
public function getFullName()
{
return $this->getClassName() . '::' . $this->getName();
}
public function getCommentText()
{
return implode(PHP_EOL, $this->comment);
}
public function getComment($indent = '')
{
$comment = $indent . '/**';
foreach ($this->comment as $line) {
$comment .= PHP_EOL . rtrim($indent . ' * ' . $line);
}
$comment .= PHP_EOL . $indent . ' */';
return $comment;
}
}
FactoryClass.php 0000664 00000002736 15152054720 0007665 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class FactoryClass
{
/**
* @var string
*/
private $file;
/**
* @var ReflectionClass
*/
private $reflector;
/**
* @var array
*/
private $methods;
public function __construct($file, ReflectionClass $class)
{
$this->file = $file;
$this->reflector = $class;
$this->extractFactoryMethods();
}
public function extractFactoryMethods()
{
$this->methods = array();
foreach ($this->getPublicStaticMethods() as $method) {
if ($method->isFactory()) {
// echo $this->getName() . '::' . $method->getName() . ' : ' . count($method->getCalls()) . PHP_EOL;
$this->methods[] = $method;
}
}
}
public function getPublicStaticMethods()
{
$methods = array();
foreach ($this->reflector->getMethods(ReflectionMethod::IS_STATIC) as $method) {
if ($method->isPublic() && $method->getDeclaringClass() == $this->reflector) {
$methods[] = new FactoryMethod($this, $method);
}
}
return $methods;
}
public function getFile()
{
return $this->file;
}
public function getName()
{
return $this->reflector->name;
}
public function isFactory()
{
return !empty($this->methods);
}
public function getMethods()
{
return $this->methods;
}
}
StaticMethodFile.php 0000664 00000001405 15152054720 0010450 0 ustar 00 <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class StaticMethodFile extends FactoryFile
{
/**
* @var string containing method definitions
*/
private $methods;
public function __construct($file)
{
parent::__construct($file, ' ');
$this->methods = '';
}
public function addCall(FactoryCall $call)
{
$this->methods .= PHP_EOL . $this->generateFactoryCall($call);
}
public function getDeclarationModifiers()
{
return 'public static ';
}
public function build()
{
$this->addFileHeader();
$this->addPart('matchers_imports');
$this->addPart('matchers_header');
$this->addCode($this->methods);
$this->addPart('matchers_footer');
}
}
