* @version $Id: eca2f1475da5e3a296736a5eefc44a1184f49f63 $
* @package phing.tasks.system
*/
class PropertyTask extends Task
{
/** name of the property */
protected $name;
/** value of the property */
protected $value;
protected $reference;
protected $env; // Environment
protected $file;
protected $ref;
protected $prefix;
protected $fallback;
/** Whether to force overwrite of existing property. */
protected $override = false;
/** Whether property should be treated as "user" property. */
protected $userProperty = false;
/**
* All filterchain objects assigned to this task
*/
protected $filterChains = array();
/** Whether to log messages as INFO or VERBOSE */
protected $logOutput = true;
/**
* @var FileParserFactoryInterface
*/
private $fileParserFactory;
/**
* @param FileParserFactoryInterface $fileParserFactory
*/
public function __construct(FileParserFactoryInterface $fileParserFactory = null)
{
$this->fileParserFactory = $fileParserFactory != null ? $fileParserFactory : new FileParserFactory();
}
/**
* Sets a the name of current property component
* @param $name
*/
public function setName($name)
{
$this->name = (string) $name;
}
/** Get property component name. */
public function getName()
{
return $this->name;
}
/**
* Sets a the value of current property component.
* @param mixed Value of name, all scalars allowed
*/
public function setValue($value)
{
$this->value = (string) $value;
}
/**
* Sets value of property to CDATA tag contents.
* @param $value
* @internal param string $values
* @since 2.2.0
*/
public function addText($value)
{
$this->setValue($value);
}
/** Get the value of current property component. */
public function getValue()
{
return $this->value;
}
/** Set a file to use as the source for properties.
* @param $file
*/
public function setFile($file)
{
if (is_string($file)) {
$file = new PhingFile($file);
}
$this->file = $file;
}
/** Get the PhingFile that is being used as property source. */
public function getFile()
{
return $this->file;
}
/**
* @param Reference $ref
*/
public function setRefid(Reference $ref)
{
$this->reference = $ref;
}
public function getRefid()
{
return $this->reference;
}
/**
* Prefix to apply to properties loaded using file.
* A "." is appended to the prefix if not specified.
* @param string $prefix prefix string
* @return void
* @since 2.0
*/
public function setPrefix($prefix)
{
$this->prefix = $prefix;
if (!StringHelper::endsWith(".", $prefix)) {
$this->prefix .= ".";
}
}
/**
* @return string
* @since 2.0
*/
public function getPrefix()
{
return $this->prefix;
}
/**
* the prefix to use when retrieving environment variables.
* Thus if you specify environment="myenv"
* you will be able to access OS-specific
* environment variables via property names "myenv.PATH" or
* "myenv.TERM".
*
* Note that if you supply a property name with a final
* "." it will not be doubled. ie environment="myenv." will still
* allow access of environment variables through "myenv.PATH" and
* "myenv.TERM". This functionality is currently only implemented
* on select platforms. Feel free to send patches to increase the number of platforms
* this functionality is supported on ;).
* Note also that properties are case sensitive, even if the
* environment variables on your operating system are not, e.g. it
* will be ${env.Path} not ${env.PATH} on Windows 2000.
* @param prefix $env
* @internal param prefix $env
*/
public function setEnvironment($env)
{
$this->env = (string) $env;
}
public function getEnvironment()
{
return $this->env;
}
/**
* Set whether this is a user property (ro).
* This is deprecated in Ant 1.5, but the userProperty attribute
* of the class is still being set via constructor, so Phing will
* allow this method to function.
* @param boolean $v
*/
public function setUserProperty($v)
{
$this->userProperty = (boolean) $v;
}
/**
* @return bool
*/
public function getUserProperty()
{
return $this->userProperty;
}
/**
* @param $v
*/
public function setOverride($v)
{
$this->override = (boolean) $v;
}
/**
* @return bool
*/
public function getOverride()
{
return $this->override;
}
/**
* @return string
*/
public function toString()
{
return (string) $this->value;
}
/**
* @param Project $p
*/
public function setFallback($p)
{
$this->fallback = $p;
}
public function getFallback()
{
return $this->fallback;
}
/**
* Creates a filterchain
*
* @return object The created filterchain object
*/
public function createFilterChain()
{
$num = array_push($this->filterChains, new FilterChain($this->project));
return $this->filterChains[$num - 1];
}
/**
* @param $logOutput
*/
public function setLogoutput($logOutput)
{
$this->logOutput = (bool) $logOutput;
}
/**
* @return bool
*/
public function getLogoutput()
{
return $this->logOutput;
}
/**
* set the property in the project to the value.
* if the task was give a file or env attribute
* here is where it is loaded
*/
public function main()
{
if ($this->name !== null) {
if ($this->value === null && $this->reference === null) {
throw new BuildException("You must specify value or refid with the name attribute", $this->getLocation(
));
}
} else {
if ($this->file === null && $this->env === null) {
throw new BuildException(
"You must specify file or environment when not using the name attribute",
$this->getLocation()
);
}
}
if ($this->file === null && $this->prefix !== null) {
throw new BuildException("Prefix is only valid when loading from a file.", $this->getLocation());
}
if (($this->name !== null) && ($this->value !== null)) {
$this->addProperty($this->name, $this->value);
}
if ($this->file !== null) {
$this->loadFile($this->file);
}
if ($this->env !== null) {
$this->loadEnvironment($this->env);
}
if (($this->name !== null) && ($this->reference !== null)) {
// get the refereced property
try {
$referencedObject = $this->reference->getReferencedObject($this->project);
if ($referencedObject instanceof Exception) {
$reference = $referencedObject->getMessage();
} else {
$reference = $referencedObject->toString();
}
$this->addProperty($this->name, $reference);
} catch (BuildException $be) {
if ($this->fallback !== null) {
$referencedObject = $this->reference->getReferencedObject($this->fallback);
if ($referencedObject instanceof Exception) {
$reference = $referencedObject->getMessage();
} else {
$reference = $referencedObject->toString();
}
$this->addProperty($this->name, $reference);
} else {
throw $be;
}
}
}
}
/**
* load the environment values
* @param string $prefix prefix to place before them
*/
protected function loadEnvironment($prefix)
{
$props = new Properties();
if (substr($prefix, strlen($prefix) - 1) == '.') {
$prefix .= ".";
}
$this->log("Loading Environment $prefix", Project::MSG_VERBOSE);
foreach ($_ENV as $key => $value) {
$props->setProperty($prefix . '.' . $key, $value);
}
$this->addProperties($props);
}
/**
* iterate through a set of properties,
* resolve them then assign them
* @param $props
* @throws BuildException
*/
protected function addProperties($props)
{
$this->resolveAllProperties($props);
foreach ($props->keys() as $name) {
$value = $props->getProperty($name);
$v = $this->project->replaceProperties($value);
if ($this->prefix !== null) {
$name = $this->prefix . $name;
}
$this->addProperty($name, $v);
}
}
/**
* add a name value pair to the project property set
* @param string $name name of property
* @param string $value value to set
*/
protected function addProperty($name, $value)
{
if (count($this->filterChains) > 0) {
$in = FileUtils::getChainedReader(new StringReader($value), $this->filterChains, $this->project);
$value = $in->read();
}
if ($this->userProperty) {
if ($this->project->getUserProperty($name) === null || $this->override) {
$this->project->setInheritedProperty($name, $value);
} else {
$this->log("Override ignored for " . $name, Project::MSG_VERBOSE);
}
} else {
if ($this->override) {
$this->project->setProperty($name, $value);
} else {
$this->project->setNewProperty($name, $value);
}
}
}
/**
* load properties from a file.
* @param PhingFile $file
* @throws BuildException
*/
protected function loadFile(PhingFile $file)
{
$fileParser = $this->fileParserFactory->createParser($file->getFileExtension());
$props = new Properties(null, $fileParser);
$this->log("Loading " . $file->getAbsolutePath(), $this->logOutput ? Project::MSG_INFO : Project::MSG_VERBOSE);
try { // try to load file
if ($file->exists()) {
$props->load($file);
$this->addProperties($props);
} else {
$this->log(
"Unable to find property file: " . $file->getAbsolutePath() . "... skipped",
Project::MSG_WARN
);
}
} catch (IOException $ioe) {
throw new BuildException("Could not load properties from file.", $ioe);
}
}
/**
* Given a Properties object, this method goes through and resolves
* any references to properties within the object.
*
* @param Properties $props The collection of Properties that need to be resolved.
* @throws BuildException
* @return void
*/
protected function resolveAllProperties(Properties $props)
{
foreach ($props->keys() as $name) {
// There may be a nice regex/callback way to handle this
// replacement, but at the moment it is pretty complex, and
// would probably be a lot uglier to work into a preg_replace_callback()
// system. The biggest problem is the fact that a resolution may require
// multiple passes.
$value = $props->getProperty($name);
$resolved = false;
$resolveStack = array();
while (!$resolved) {
$fragments = array();
$propertyRefs = array();
// [HL] this was ::parsePropertyString($this->value ...) ... this seems wrong
self::parsePropertyString($value, $fragments, $propertyRefs);
$resolved = true;
if (count($propertyRefs) == 0) {
continue;
}
$sb = "";
$j = $propertyRefs;
foreach ($fragments as $fragment) {
if ($fragment !== null) {
$sb .= $fragment;
continue;
}
$propertyName = array_shift($j);
if (in_array($propertyName, $resolveStack)) {
// Should we maybe just log this as an error & move on?
// $this->log("Property ".$name." was circularly defined.", Project::MSG_ERR);
throw new BuildException("Property " . $propertyName . " was circularly defined.");
}
$fragment = $this->getProject()->getProperty($propertyName);
if ($fragment !== null) {
$sb .= $fragment;
continue;
}
if ($props->containsKey($propertyName)) {
$fragment = $props->getProperty($propertyName);
if (strpos($fragment, '${') !== false) {
$resolveStack[] = $propertyName;
$resolved = false; // parse again (could have been replaced w/ another var)
}
} else {
$fragment = "\${" . $propertyName . "}";
}
$sb .= $fragment;
}
$this->log("Resolved Property \"$value\" to \"$sb\"", Project::MSG_DEBUG);
$value = $sb;
$props->setProperty($name, $value);
} // while (!$resolved)
} // while (count($keys)
}
/**
* This method will parse a string containing ${value} style
* property values into two lists. The first list is a collection
* of text fragments, while the other is a set of string property names
* null entries in the first list indicate a property reference from the
* second list.
*
* This is slower than regex, but useful for this class, which has to handle
* multiple parsing passes for properties.
*
* @param string $value The string to be scanned for property references
* @param array &$fragments The found fragments
* @param array &$propertyRefs The found refs
* @throws BuildException
*/
protected function parsePropertyString($value, &$fragments, &$propertyRefs)
{
$prev = 0;
$pos = 0;
while (($pos = strpos($value, '$', $prev)) !== false) {
if ($pos > $prev) {
array_push($fragments, StringHelper::substring($value, $prev, $pos - 1));
}
if ($pos === (strlen($value) - 1)) {
array_push($fragments, '$');
$prev = $pos + 1;
} elseif ($value{$pos + 1} !== '{') {
// the string positions were changed to value-1 to correct
// a fatal error coming from function substring()
array_push($fragments, StringHelper::substring($value, $pos, $pos + 1));
$prev = $pos + 2;
} else {
$endName = strpos($value, '}', $pos);
if ($endName === false) {
throw new BuildException("Syntax error in property: $value");
}
$propertyName = StringHelper::substring($value, $pos + 2, $endName - 1);
array_push($fragments, null);
array_push($propertyRefs, $propertyName);
$prev = $endName + 1;
}
}
if ($prev < strlen($value)) {
array_push($fragments, StringHelper::substring($value, $prev));
}
}
}
phing-2.14.0/tasks/system/MatchingTask.php 0000775 0001750 0001750 00000025650 12670364674 020304 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/types/selectors/SelectorContainer.php';
include_once 'phing/types/FileSet.php';
include_once 'phing/types/PatternSet.php';
include_once 'phing/util/DirectoryScanner.php';
/**
* This is an abstract task that should be used by all those tasks that
* require to include or exclude files based on pattern matching.
*
* This is very closely based on the ANT class of the same name.
*
* @author Hans Lellelid (Phing)
* @author Arnout J. Kuiper (Ant)
* @author Stefano Mazzocchi (Ant)
* @author Sam Ruby (Ant)
* @author Jon S. Stevens (Ant
* @author Stefan Bodewig (Ant)
* @author Bruce Atherton (Ant)
* @version $Id: 0de09dc2fc5e271ecbfbb358c65130cd4876301f $
* @package phing.tasks.system
*/
abstract class MatchingTask extends Task implements SelectorContainer
{
/** @var boolean */
protected $useDefaultExcludes = true;
/** @var FileSet */
protected $fileset;
/**
* Create instance; set fileset to new FileSet.
*/
public function __construct()
{
$this->fileset = new FileSet();
}
/**
* @see ProjectComponent::setProject()
* @param Project $project
*/
public function setProject($project)
{
parent::setProject($project);
$this->fileset->setProject($project);
}
/**
* add a name entry on the include list
* @return PatternSetNameEntry
*/
public function createInclude()
{
return $this->fileset->createInclude();
}
/**
* add a name entry on the include files list
* @return PatternSetNameEntry
*/
public function createIncludesFile()
{
return $this->fileset->createIncludesFile();
}
/**
* add a name entry on the exclude list
* @return PatternSetNameEntry
*/
public function createExclude()
{
return $this->fileset->createExclude();
}
/**
* add a name entry on the include files list
* @return PatternSetNameEntry
*/
public function createExcludesFile()
{
return $this->fileset->createExcludesFile();
}
/**
* add a set of patterns
* @return PatternSet
*/
public function createPatternSet()
{
return $this->fileset->createPatternSet();
}
/**
* Sets the set of include patterns. Patterns may be separated by a comma
* or a space.
*
* @param string $includes the string containing the include patterns
* @return void
*/
public function setIncludes($includes)
{
$this->fileset->setIncludes($includes);
}
/**
* Sets the set of exclude patterns. Patterns may be separated by a comma
* or a space.
*
* @param string $excludes the string containing the exclude patterns
*/
public function setExcludes($excludes)
{
$this->fileset->setExcludes($excludes);
}
/**
* Sets whether default exclusions should be used or not.
*
* @param boolean $useDefaultExcludes "true"|"on"|"yes" when default exclusions
* should be used, "false"|"off"|"no" when they
* shouldn't be used.
*/
public function setDefaultexcludes($useDefaultExcludes)
{
$this->useDefaultExcludes = (boolean) $useDefaultExcludes;
}
/**
* Returns the directory scanner needed to access the files to process.
* @param PhingFile $baseDir
* @throws BuildException
* @return DirectoryScanner
*/
protected function getDirectoryScanner(PhingFile $baseDir)
{
$this->fileset->setDir($baseDir);
$this->fileset->setDefaultexcludes($this->useDefaultExcludes);
return $this->fileset->getDirectoryScanner($this->project);
}
/**
* Sets the name of the file containing the includes patterns.
*
* @param PhingFile $includesfile A string containing the filename to fetch
* the include patterns from.
* @return void
*/
public function setIncludesfile(PhingFile $includesfile)
{
$this->fileset->setIncludesfile($includesfile);
}
/**
* Sets the name of the file containing the includes patterns.
*
* @param PhingFile $excludesfile A string containing the filename to fetch
* the include patterns from.
* @return void
*/
public function setExcludesfile(PhingFile $excludesfile)
{
$this->fileset->setExcludesfile($excludesfile);
}
/**
* Sets case sensitivity of the file system
*
* @param boolean $isCaseSensitive "true"|"on"|"yes" if file system is case
* sensitive, "false"|"off"|"no" when not.
* @return void
*/
public function setCaseSensitive($isCaseSensitive)
{
$this->fileset->setCaseSensitive($isCaseSensitive);
}
/**
* Sets whether or not symbolic links should be followed.
*
* @param boolean $followSymlinks whether or not symbolic links should be followed
* @return void
*/
public function setFollowSymlinks($followSymlinks)
{
$this->fileset->setFollowSymlinks($followSymlinks);
}
/**
* Indicates whether there are any selectors here.
*
* @return boolean Whether any selectors are in this container
*/
public function hasSelectors()
{
return $this->fileset->hasSelectors();
}
/**
* Gives the count of the number of selectors in this container
*
* @return int The number of selectors in this container
*/
public function selectorCount()
{
return $this->fileset->selectorCount();
}
/**
* Returns the set of selectors as an array.
*
* @param Project $p
* @return array FileSelector[] An array of selectors in this container
*/
public function getSelectors(Project $p)
{
return $this->fileset->getSelectors($p);
}
/**
* Returns an enumerator for accessing the set of selectors.
*
* @return an enumerator that goes through each of the selectors
*/
public function selectorElements()
{
return $this->fileset->selectorElements();
}
/**
* Add a new selector into this container.
*
* @param FileSelector $selector the new selector to add
* @return void
*/
public function appendSelector(FileSelector $selector)
{
$this->fileset->appendSelector($selector);
}
/* Methods below all add specific selectors */
/**
* add a "Select" selector entry on the selector list
* @return SelectSelector
*/
public function createSelector()
{
return $this->fileset->createSelector();
}
/**
* add an "And" selector entry on the selector list
* @return AndSelector
*/
public function createAnd()
{
return $this->fileset->createAnd();
}
/**
* add an "Or" selector entry on the selector list
* @return OrSelector
*/
public function createOr()
{
return $this->fileset->createOr();
}
/**
* add a "Not" selector entry on the selector list
* @return NotSelector
*/
public function createNot()
{
return $this->fileset->createNot();
}
/**
* add a "None" selector entry on the selector list
* @return NoneSelector
*/
public function createNone()
{
return $this->fileset->createNone();
}
/**
* add a majority selector entry on the selector list
* @return MajoritySelector
*/
public function createMajority()
{
return $this->fileset->createMajority();
}
/**
* add a selector date entry on the selector list
* @return DateSelector
*/
public function createDate()
{
return $this->fileset->createDate();
}
/**
* add a selector size entry on the selector list
* @return SizeSelector
*/
public function createSize()
{
return $this->fileset->createSize();
}
/**
* add a selector filename entry on the selector list
* @return FilenameSelector
*/
public function createFilename()
{
return $this->fileset->createFilename();
}
/**
* add an extended selector entry on the selector list
* @return ExtendSelector
*/
public function createCustom()
{
return $this->fileset->createCustom();
}
/**
* add a contains selector entry on the selector list
* @return ContainsSelector
*/
public function createContains()
{
return $this->fileset->createContains();
}
/**
* add a present selector entry on the selector list
* @return PresentSelector
*/
public function createPresent()
{
return $this->fileset->createPresent();
}
/**
* add a depth selector entry on the selector list
* @return DepthSelector
*/
public function createDepth()
{
return $this->fileset->createDepth();
}
/**
* add a depends selector entry on the selector list
* @return DependSelector
*/
public function createDepend()
{
return $this->fileset->createDepend();
}
/**
* add a readable selector entry on the selector list
* @return ReadableSelector
*/
public function createReadable()
{
return $this->fileset->createReadable();
}
/**
* add a writable selector entry on the selector list
* @return WritableSelector
*/
public function createWritable()
{
return $this->fileset->createWritable();
}
/**
* Accessor for the implict fileset.
*
* @return FileSet
*/
final protected function getImplicitFileSet()
{
return $this->fileset;
}
}
phing-2.14.0/tasks/system/Basename.php 0000664 0001750 0001750 00000006510 12670364674 017431 0 ustar michiel michiel .
*/
include_once 'phing/BuildException.php';
include_once 'phing/Task.php';
include_once 'phing/system/io/PhingFile.php';
include_once 'phing/util/StringHelper.php';
/**
* Task that changes the permissions on a file/directory.
*
* @author Siad Ardroumli
* @package phing.tasks.system
*/
class Basename extends Task
{
/** @var PhingFile $file */
private $file;
/** @var string $property */
private $property;
/** @var string $suffix */
private $suffix;
/**
* file or directory to get base name from
* @param PhingFile $file file or directory to get base name from
*/
public function setFile($file)
{
if (is_string($file)) {
$this->file = new PhingFile($file);
} else {
$this->file = $file;
}
}
/**
* Property to set base name to.
* @param string $property name of property
*/
public function setProperty($property)
{
$this->property = $property;
}
/**
* Optional suffix to remove from base name.
* @param string $suffix suffix to remove from base name
*/
public function setSuffix($suffix)
{
$this->suffix = $suffix;
}
/**
* do the work
* @throws BuildException if required attributes are not supplied
* property and attribute are required attributes
*/
public function main()
{
if ($this->property === null) {
throw new BuildException("property attribute required", $this->getLocation());
}
if ($this->file == null) {
throw new BuildException("file attribute required", $this->getLocation());
}
$value = $this->file->getName();
if ($this->suffix != null && StringHelper::endsWith($this->suffix, $value)) {
// if the suffix does not starts with a '.' and the
// char preceding the suffix is a '.', we assume the user
// wants to remove the '.' as well
$pos = strlen($value) - strlen($this->suffix) - 1;
if ($pos > 0 && $this->suffix{0} !== '.' && $value{$pos} === '.') {
$pos--;
}
$value = StringHelper::substring($value, 0, $pos);
}
$this->getProject()->setNewProperty($this->property, $value);
}
}
phing-2.14.0/tasks/system/IncludePathTask.php 0000775 0001750 0001750 00000011607 12670364674 020747 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
include_once 'phing/types/Path.php';
/**
* Adds a normalized path to the PHP include_path.
*
* This provides a way to alter the include_path without editing any global php.ini settings
* or PHP_CLASSPATH environment variable.
*
*
*
*
*
* @author Hans Lellelid
* @version $Id: 543e5401804eda643673c4ae52d20dcfe8104833 $
* @package phing.tasks.system
*/
class IncludePathTask extends Task
{
/**
* Classname of task to register.
* This can be a dot-path -- relative to a location on PHP include_path.
* E.g. path.to.MyClass -> path/to/MyClass.php
* @var string
*/
private $classname;
/**
* Path to add to PHP include_path to aid in finding specified class.
* @var Path
*/
private $classpath;
/**
* Refid to already defined classpath
*/
private $classpathId;
/**
* Whether to prepend, append or replace the include path
* @var string
*/
private $mode = "prepend";
/**
* Set the classpath to be used when searching for component being defined
*
* @param Path $classpath An Path object containing the classpath.
*/
public function setClasspath(Path $classpath)
{
if ($this->classpath === null) {
$this->classpath = $classpath;
} else {
$this->classpath->append($classpath);
}
}
/**
* Create the classpath to be used when searching for component being defined
*/
public function createClasspath()
{
if ($this->classpath === null) {
$this->classpath = new Path($this->project);
}
return $this->classpath->createPath();
}
/**
* Reference to a classpath to use when loading the files.
* @param Reference $r
* @throws BuildException
*/
public function setClasspathRef(Reference $r)
{
$this->classpathId = $r->getRefId();
$this->createClasspath()->setRefid($r);
}
/**
* @param $mode
* @throws BuildException
*/
public function setMode($mode)
{
if (!in_array($mode, array('append', 'prepend', 'replace'))) {
throw new BuildException("Illegal mode: needs to be either append, prepend or replace");
}
$this->mode = $mode;
}
/** Main entry point */
public function main()
{
// Apparently casting to (string) no longer invokes __toString() automatically.
if (is_object($this->classpath)) {
$classpath = $this->classpath->__toString();
}
if (empty($classpath)) {
throw new BuildException("Provided classpath was empty.");
}
$curr_parts = Phing::explodeIncludePath();
$add_parts = Phing::explodeIncludePath($classpath);
$new_parts = array_diff($add_parts, $curr_parts);
if ($new_parts) {
$this->updateIncludePath($new_parts, $curr_parts);
}
}
/**
* @param $new_parts
* @param $curr_parts
*/
private function updateIncludePath($new_parts, $curr_parts)
{
$includePath = array();
$verb = "";
switch ($this->mode) {
case "append":
$includePath = array_merge($curr_parts, $new_parts);
$verb = "Appending";
break;
case "replace":
$includePath = $new_parts;
$verb = "Replacing";
break;
case "prepend":
$includePath = array_merge($new_parts, $curr_parts);
$verb = "Prepending";
break;
}
$this->log(
$verb . " new include_path components: " . implode(PATH_SEPARATOR, $new_parts),
Project::MSG_VERBOSE
);
set_include_path(implode(PATH_SEPARATOR, $includePath));
}
}
phing-2.14.0/tasks/system/SwitchTask.php 0000664 0001750 0001750 00000012514 12670364674 020003 0 ustar michiel michiel .
*/
include_once 'phing/Task.php';
require_once 'phing/tasks/system/SequentialTask.php';
/**
* Task definition for the phing task to switch on a particular value.
*
* Task calling syntax:
* ```
*
*
* |
* |
* any other tasks
*
* [
*
* |
* |
* any other tasks
*
* ]
*
* ```
*
*
* Attributes:
* value -> The value to switch on
* caseinsensitive -> Should we do case insensitive comparisons?
* (default is false)
*
* Subitems:
* case --> An individual case to consider, if the value that
* is being switched on matches to value attribute of
* the case, then the nested tasks will be executed.
* default --> The default case for when no match is found.
*
*
* Crude Example:
*
* ```
*
*
*
*
*
*
*
*
*
*
*
* ```
*
* @author Siad Ardroumli
* @package phing.tasks.system
*/
class SwitchTask extends Task
{
/** @var mixed $value */
private $value = null;
/** @var array $cases */
private $cases = array();
/** @var SequentialTask $defaultCase */
private $defaultCase = null;
/** @var bool $caseInsensitive */
private $caseInsensitive = false;
/***
* Sets the value being switched on.
*
* @param mixed $value
*
* @return void
*/
public function setValue($value)
{
$this->value = $value;
}
/**
* Adds a CaseTask.
*
* @param CaseTask $case
*
* @return void
*/
public function addCase(CaseTask $case)
{
$this->cases[] = $case;
}
/**
* @param $bool
*
* @return void
*/
public function setCaseInsensitive($bool)
{
$this->caseInsensitive = $bool;
}
/**
* Creates the `` tag
*/
public function addDefault(SequentialTask $res)
{
if ($this->defaultCase !== null) {
throw new BuildException("Cannot specify multiple default cases");
}
$this->defaultCase = $res;
}
public function main()
{
if ($this->value === null) {
throw new BuildException("Value is missing ");
}
if (empty($this->cases) && $this->defaultCase === null) {
throw new BuildException("No cases supplied ");
}
$selectedCase = $this->defaultCase;
/** @var CaseTask $case */
foreach ($this->cases as $case) {
$cValue = $case->getValue();
if (empty($case)) {
throw new BuildException("Value is required for case.");
}
$mValue = $this->value;
if ($this->caseInsensitive) {
$cValue = strtoupper($case->getValue());
$mValue = strtoupper($this->value);
}
if ($cValue === $mValue && $case != $this->defaultCase) {
$selectedCase = $case;
}
}
if ($selectedCase === null) {
throw new BuildException("No case matched the value " . $this->value . " and no default has been specified.");
}
$selectedCase->perform();
}
}
/**
* "Inner" class for SwitchTask.
*
* @package phing.tasks.system
*/
class CaseTask extends SequentialTask
{
/** @var mixed $value */
private $value = null;
/**
* @param $value
*
* @return void
*/
public function setValue($value)
{
$this->value = $value;
}
/**
* @return mixed
*/
public function getValue()
{
return $this->value;
}
/**
* {@inheritdoc}
*/
public function main()
{
/** @var Task $task */
foreach ($this->nestedTasks as $task) {
$task->perform();
}
}
}
phing-2.14.0/tasks/system/TstampTask.php 0000775 0001750 0001750 00000010653 12670364674 020017 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* Sets properties to the current time, or offsets from the current time.
* The default properties are TSTAMP, DSTAMP and TODAY;
*
* Based on Ant's Tstamp task.
*
* @author Michiel Rook
* @version $Id: 02ac32dcbb53394d677a9ee39479f3b427306896 $
* @package phing.tasks.system
* @since 2.2.0
*/
class TstampTask extends Task
{
private $customFormats = array();
private $prefix = "";
/**
* Set a prefix for the properties. If the prefix does not end with a "."
* one is automatically added.
* @param string $prefix the prefix to use.
*/
public function setPrefix($prefix)
{
$this->prefix = $prefix;
if (!empty($this->prefix)) {
$this->prefix .= ".";
}
}
/**
* Adds a custom format
*
* @param TstampCustomFormat custom format
*/
public function addFormat(TstampCustomFormat $cf)
{
$this->customFormats[] = $cf;
}
/**
* Create the timestamps. Custom ones are done before
* the standard ones.
*
* @throws BuildException
*/
public function main()
{
foreach ($this->customFormats as $cf) {
$cf->execute($this);
}
$dstamp = strftime('%Y%m%d');
$this->prefixProperty('DSTAMP', $dstamp);
$tstamp = strftime('%H%M');
$this->prefixProperty('TSTAMP', $tstamp);
$today = strftime('%B %d %Y');
$this->prefixProperty('TODAY', $today);
}
/**
* helper that encapsulates prefix logic and property setting
* policy (i.e. we use setNewProperty instead of setProperty).
* @param $name
* @param $value
*/
public function prefixProperty($name, $value)
{
$this->getProject()->setNewProperty($this->prefix . $name, $value);
}
}
/**
* @package phing.tasks.system
*/
class TstampCustomFormat
{
private $propertyName = "";
private $pattern = "";
private $locale = "";
/**
* The property to receive the date/time string in the given pattern
*
* @param string $propertyName the name of the property.
*/
public function setProperty($propertyName)
{
$this->propertyName = $propertyName;
}
/**
* The date/time pattern to be used. The values are as
* defined by the PHP strftime() function.
*
* @param pattern
*/
public function setPattern($pattern)
{
$this->pattern = $pattern;
}
/**
* The locale used to create date/time string.
*
* @param string $locale
*/
public function setLocale($locale)
{
$this->locale = $locale;
}
/**
* validate parameter and execute the format.
*
* @param TstampTask $tstamp reference to task
* @throws BuildException
*/
public function execute(TstampTask $tstamp)
{
if (empty($this->propertyName)) {
throw new BuildException("property attribute must be provided");
}
if (empty($this->pattern)) {
throw new BuildException("pattern attribute must be provided");
}
if (!empty($this->locale)) {
setlocale(LC_ALL, $this->locale);
}
$value = strftime($this->pattern);
$tstamp->prefixProperty($this->propertyName, $value);
if (!empty($this->locale)) {
// reset locale
setlocale(LC_ALL, null);
}
}
}
phing-2.14.0/tasks/system/MoveTask.php 0000775 0001750 0001750 00000017016 12670364674 017455 0 ustar michiel michiel .
*/
require_once 'phing/tasks/system/CopyTask.php';
include_once 'phing/system/io/PhingFile.php';
include_once 'phing/system/io/IOException.php';
/**
* Moves a file or directory to a new file or directory.
*
* By default, the destination file is overwritten if it
* already exists. When overwrite is turned off, then files
* are only moved if the source file is newer than the
* destination file, or when the destination file does not
* exist.
*
* Source files and directories are only deleted when the file or
* directory has been copied to the destination successfully.
*
* @package phing.tasks.system
*/
class MoveTask extends CopyTask
{
/**
*
*/
public function __construct()
{
parent::__construct();
$this->forceOverwrite = true;
}
/**
* Validates attributes coming in from XML
*
* @return void
*
* @throws BuildException
*/
protected function validateAttributes()
{
if ($this->file !== null && $this->file->isDirectory()) {
if (($this->destFile !== null && $this->destDir !== null)
|| ($this->destFile === null && $this->destDir === null)
) {
throw new BuildException("One and only one of tofile and todir must be set.");
}
if ($this->destFile === null) {
$this->destFile = new PhingFile($this->destDir, $this->file->getName());
}
if ($this->destDir === null) {
$this->destDir = $this->destFile->getParentFile();
}
$this->completeDirMap[$this->file->getAbsolutePath()] = $this->destFile->getAbsolutePath();
$this->file = null;
} else {
parent::validateAttributes();
}
}
protected function doWork()
{
if (count($this->completeDirMap) > 0) {
foreach ($this->completeDirMap as $from => $to) {
$f = new PhingFile($from);
$d = new PhingFile($to);
$moved = false;
try { // try to rename
$this->log("Attempting to rename $from to $to", $this->verbosity);
$this->fileUtils->copyFile(
$f,
$d,
$this->forceOverwrite,
$this->preserveLMT,
$this->filterChains,
$this->getProject(),
$this->mode
);
$f->delete(true);
$moved = true;
} catch (IOException $ioe) {
$moved = false;
$this->logError("Failed to rename $from to $to: " . $ioe->getMessage());
}
}
}
$copyMapSize = count($this->fileCopyMap);
if ($copyMapSize > 0) {
// files to move
$this->log("Moving $copyMapSize files to " . $this->destDir->getAbsolutePath());
foreach ($this->fileCopyMap as $from => $to) {
if ($from == $to) {
$this->log("Skipping self-move of $from", $this->verbosity);
continue;
}
$f = new PhingFile($from);
$d = new PhingFile($to);
try { // try to move
$this->log("Moving $from to $to", $this->verbosity);
$this->fileUtils->copyFile(
$f,
$d,
$this->forceOverwrite,
$this->preserveLMT,
$this->filterChains,
$this->getProject(),
$this->mode
);
$f->delete();
} catch (IOException $ioe) {
$this->logError("Failed to move $from to $to: " . $ioe->getMessage(), $this->location);
}
} // foreach fileCopyMap
} // if copyMapSize
// handle empty dirs if appropriate
if ($this->includeEmpty) {
$count = 0;
foreach ($this->dirCopyMap as $srcDir => $destDir) {
$d = new PhingFile((string) $destDir);
if (!$d->exists()) {
if (!$d->mkdirs()) {
$this->logError("Unable to create directory " . $d->getAbsolutePath());
} else {
$count++;
}
}
}
if ($count > 0) {
$this->log(
"moved $count empty director" . ($count == 1 ? "y" : "ies") . " to " . $this->destDir->getAbsolutePath(
)
);
}
}
if (count($this->filesets) > 0) {
// process filesets
foreach ($this->filesets as $fs) {
$dir = $fs->getDir($this->project);
if ($this->okToDelete($dir)) {
$this->deleteDir($dir);
}
}
}
}
/**
* Its only ok to delete a dir tree if there are no files in it.
*
* @param $d
*
* @throws IOException
*
* @return bool
*/
private function okToDelete($d)
{
$list = $d->listDir();
if ($list === null) {
return false; // maybe io error?
}
foreach ($list as $s) {
$f = new PhingFile($d, $s);
if ($f->isDirectory()) {
if (!$this->okToDelete($f)) {
return false;
}
} else {
// found a file
return false;
}
}
return true;
}
/**
* Go and delete the directory tree.
*
* @param $d
*
* @throws BuildException
* @throws IOException
*/
private function deleteDir($d)
{
$list = $d->listDir();
if ($list === null) {
return; // on an io error list() can return null
}
foreach ($list as $fname) {
$f = new PhingFile($d, $fname);
if ($f->isDirectory()) {
$this->deleteDir($f);
} else {
throw new BuildException("UNEXPECTED ERROR - The file " . $f->getAbsolutePath() . " should not exist!");
}
}
$this->log("Deleting directory " . $d->getPath(), $this->verbosity);
try {
$d->delete();
} catch (Exception $e) {
$this->logError("Unable to delete directory " . $d->__toString() . ": " . $e->getMessage());
}
}
}
phing-2.14.0/tasks/system/TypedefTask.php 0000775 0001750 0001750 00000010140 12670364674 020136 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* Register a datatype for use within a buildfile.
*
* This is for registering your own datatypes for use within a buildfile.
*
* If you find that you are using a particular class frequently, you may want to edit the
* phing/types/defaults.properties file so that it is included by default. You may also
* want to submit it (if LGPL or compatible license) to be included in Phing distribution.
*
*
*
* .
*
*
*
*
*
* TODO:
* -- possibly refactor since this is almost the same as TaskDefTask
* (right now these are just too simple to really justify creating an abstract class)
*
* @author Hans Lellelid
* @version $Id: f91ebca00240cc8f22e642115e0aa0da140dc4a4 $
* @package phing.tasks.system
*/
class TypedefTask extends Task
{
/** Tag name for datatype that will be used in XML */
private $name;
/**
* Classname of task to register.
* This can be a dot-path -- relative to a location on PHP include_path.
* E.g. path.to.MyClass -> path/to/MyClass.php
* @var string
*/
private $classname;
/**
* Path to add to PHP include_path to aid in finding specified class.
* @var Path
*/
private $classpath;
/** Refid to already defined classpath */
private $classpathId;
/**
* Set the classpath to be used when searching for component being defined
*
* @param Path $classpath A Path object containing the classpath.
*/
public function setClasspath(Path $classpath)
{
if ($this->classpath === null) {
$this->classpath = $classpath;
} else {
$this->classpath->append($classpath);
}
}
/**
* Create the classpath to be used when searching for component being defined
*
* @return Path
*/
public function createClasspath()
{
if ($this->classpath === null) {
$this->classpath = new Path($this->project);
}
return $this->classpath->createPath();
}
/**
* Reference to a classpath to use when loading the files.
* @param Reference $r
*/
public function setClasspathRef(Reference $r)
{
$this->classpathId = $r->getRefId();
$this->createClasspath()->setRefid($r);
}
/** Main entry point */
public function main()
{
if ($this->name === null || $this->classname === null) {
throw new BuildException("You must specify name and class attributes for .");
}
$this->project->addDataTypeDefinition($this->name, $this->classname, $this->classpath);
}
/**
* Sets the name that will be used in XML buildfile.
* @param string $name
*/
public function setName($name)
{
$this->name = $name;
}
/**
* Sets the class name / dotpath to use.
* @param string $class
*/
public function setClassname($class)
{
$this->classname = $class;
}
}
phing-2.14.0/tasks/system/ResolvePathTask.php 0000775 0001750 0001750 00000012140 12670364674 020774 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* Task for resolving relative paths and setting absolute path in property value.
*
* This task was created to address a need for resolving absolute paths of files / directories.
* In many cases a relative directory (e.g. "./build") is specified, but it needs to be treated
* as an absolute path since other build files (e.g. in subdirs) should all be using the same
* path -- and not treating it as a relative path to their own directory.
*
*
*
*
* Resolved [absolute] path: ${absolute_path}
*
*
* TODO:
* - Possibly integrate this with PackageAsPath, for handling/resolving dot-path paths.
*
* @author Hans Lellelid
* @version $Id: 9c026ad2bcf52981754fad867fdda21e161277aa $
* @package phing.tasks.system
*/
class ResolvePathTask extends Task
{
/** Name of property to set. */
private $propertyName;
/** The [possibly] relative file/path that needs to be resolved. */
private $file;
/** Base directory used for resolution.
* @var PhingFile
*/
private $dir;
/**
* Log level
*/
private $logLevel = Project::MSG_VERBOSE;
/**
* Set the name of the property to set.
* @param string $v Property name
* @return void
*/
public function setPropertyName($v)
{
$this->propertyName = $v;
}
/**
* Sets a base dir to use for resolution.
* @param PhingFile $d
*/
public function setDir(PhingFile $d)
{
$this->dir = $d;
}
/**
* Sets a path (file or directory) that we want to resolve.
* This is the same as setFile() -- just more generic name so that it's
* clear that you can also use it to set directory.
* @param string $f
* @see setFile()
*/
public function setPath($f)
{
$this->file = $f;
}
/**
* Sets a file that we want to resolve.
* @param string $f
*/
public function setFile($f)
{
$this->file = $f;
}
/**
* Set level of log messages generated (default = verbose)
*
* @param string $level Log level
*
* @throws BuildException
* @return void
*/
public function setLevel($level)
{
switch ($level) {
case 'error':
$this->logLevel = Project::MSG_ERR;
break;
case 'warning':
$this->logLevel = Project::MSG_WARN;
break;
case 'info':
$this->logLevel = Project::MSG_INFO;
break;
case 'verbose':
$this->logLevel = Project::MSG_VERBOSE;
break;
case 'debug':
$this->logLevel = Project::MSG_DEBUG;
break;
default:
throw new BuildException(
sprintf('Unknown log level "%s"', $level)
);
}
}
/**
* Perform the resolution & set property.
*/
public function main()
{
if (!$this->propertyName) {
throw new BuildException("You must specify the propertyName attribute", $this->getLocation());
}
// Currently only files are supported
if ($this->file === null) {
throw new BuildException("You must specify a path to resolve", $this->getLocation());
}
$fs = FileSystem::getFileSystem();
// if dir attribute was specified then we should
// use that as basedir to which file was relative.
// -- unless the file specified is an absolute path
if ($this->dir !== null && !$fs->isAbsolute(new PhingFile($this->file))) {
$this->file = new PhingFile($this->dir->getPath(), $this->file);
}
$resolved = $this->project->resolveFile($this->file);
$this->log("Resolved " . $this->file . " to " . $resolved->getAbsolutePath(), $this->logLevel);
$this->project->setProperty($this->propertyName, $resolved->getAbsolutePath());
}
}
phing-2.14.0/tasks/system/TempFile.php 0000664 0001750 0001750 00000011520 12670364674 017420 0 ustar michiel michiel .
*/
include_once 'phing/Task.php';
include_once 'phing/system/io/PhingFile.php';
include_once 'phing/BuildException.php';
/**
* This task sets a property to the name of a temporary file.
* Unlike {@link PhingFile::createTempFile()}, this task does not (by default) actually create the
* temporary file, but it does guarantee that the file did not
* exist when the task was executed.
*
* Examples:
*
* ``
*
* create a temporary file
*
* ``
*
* create a temporary file with the .xml suffix.
*
* ``
*
* create a temp file in the build subdir
*
* @author Siad Ardroumli
* @package phing.tasks.system
*/
class TempFile extends Task
{
/**
* Name of property to set.
*/
private $property = '';
/**
* Directory to create the file in. Can be null.
*/
private $destDir;
/**
* Prefix for the file.
*/
private $prefix;
/**
* Suffix for the file.
*/
private $suffix = '';
/** deleteOnExit flag */
private $deleteOnExit;
/** createFile flag */
private $createFile;
/**
* Sets the property you wish to assign the temporary file to.
*
* @param string $property The property to set
*/
public function setProperty($property)
{
$this->property = $property;
}
/**
* Sets the destination directory. If not set,
* the basedir directory is used instead.
*
* @param string|PhingFile $destDir The new destDir value
*/
public function setDestDir($destDir)
{
if ($destDir instanceof PhingFile) {
$this->destDir = $destDir;
} else {
$this->destDir = new PhingFile($destDir);
}
}
/**
* Sets the optional prefix string for the temp file.
*
* @param string $prefix string to prepend to generated string
*/
public function setPrefix($prefix)
{
$this->prefix = $prefix;
}
/**
* Sets the optional suffix string for the temp file.
*
* @param string $suffix suffix including any "." , e.g ".xml"
*/
public function setSuffix($suffix)
{
$this->suffix = $suffix;
}
/**
* Set whether the tempfile created by this task should be set
* for deletion on normal VM exit.
* @param boolean $deleteOnExit boolean flag.
*/
public function setDeleteOnExit($deleteOnExit)
{
$this->deleteOnExit = $deleteOnExit;
}
/**
* Learn whether deleteOnExit is set for this tempfile task.
* @return boolean deleteOnExit flag.
*/
public function isDeleteOnExit()
{
return $this->deleteOnExit;
}
/**
* If set the file is actually created, if not just a name is created.
* @param boolean $createFile boolean flag.
*/
public function setCreateFile($createFile)
{
$this->createFile = $createFile;
}
/**
* Learn whether createFile flag is set for this tempFile task.
* @return boolean the createFile flag.
*/
public function isCreateFile()
{
return $this->createFile;
}
/**
* Creates the temporary file.
*
* @throws BuildException if something goes wrong with the build
*/
public function main()
{
if ($this->property === '') {
throw new BuildException('no property specified');
}
if ($this->destDir === null) {
$this->destDir = $this->getProject()->resolveFile('.');
}
$fu = new FileUtils;
$tmpFile = $fu->createTempFile(
$this->prefix,
$this->suffix,
$this->destDir,
$this->deleteOnExit,
$this->createFile
);
$this->getProject()->setNewProperty($this->property, $tmpFile->toString());
}
}
phing-2.14.0/tasks/system/ExecTask.php 0000775 0001750 0001750 00000033415 12670364674 017434 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* Executes a command on the shell.
*
* @author Andreas Aderhold
* @author Hans Lellelid
* @author Christian Weiske
* @version $Id: 4608acf4d70eed8ca1d609fe5b3a2122b0c9705c $
* @package phing.tasks.system
*/
class ExecTask extends Task
{
const INVALID = PHP_INT_MAX;
private $exitValue = self::INVALID;
/**
* Command to be executed
* @var string
*/
protected $realCommand;
/**
* Given command
* @var string
*/
protected $command;
/**
* Commandline managing object
*
* @var Commandline
*/
protected $commandline;
/**
* Working directory.
* @var PhingFile
*/
protected $dir;
protected $currdir;
/**
* Operating system.
* @var string
*/
protected $os;
/**
* Whether to escape shell command using escapeshellcmd().
* @var boolean
*/
protected $escape = false;
/**
* Where to direct output.
* @var PhingFile
*/
protected $output;
/**
* Whether to use PHP's passthru() function instead of exec()
* @var boolean
*/
protected $passthru = false;
/**
* Whether to log returned output as MSG_INFO instead of MSG_VERBOSE
* @var boolean
*/
protected $logOutput = false;
/**
* Logging level for status messages
* @var integer
*/
protected $logLevel = Project::MSG_VERBOSE;
/**
* Where to direct error output.
* @var PhingFile
*/
protected $error;
/**
* If spawn is set then [unix] programs will redirect stdout and add '&'.
* @var boolean
*/
protected $spawn = false;
/**
* Property name to set with return value from exec call.
*
* @var string
*/
protected $returnProperty;
/**
* Property name to set with output value from exec call.
*
* @var string
*/
protected $outputProperty;
/**
* Whether to check the return code.
* @var boolean
*/
protected $checkreturn = false;
/**
*
*/
public function __construct()
{
$this->commandline = new Commandline();
}
/**
* Main method: wraps execute() command.
*
* @return void
*/
public function main()
{
if (!$this->isApplicable()) {
return;
}
$this->prepare();
$this->buildCommand();
list($return, $output) = $this->executeCommand();
$this->cleanup($return, $output);
}
/**
* Checks whether the command shall be executed
*
* @return boolean False if the exec command shall not be run
*/
protected function isApplicable()
{
if ($this->os === null) {
return true;
}
$myos = Phing::getProperty('os.name');
$this->log('Myos = ' . $myos, Project::MSG_VERBOSE);
if (strpos($this->os, $myos) !== false) {
// this command will be executed only on the specified OS
// OS matches
return true;
}
$this->log(
sprintf(
'Operating system %s not found in %s',
$myos,
$this->os
),
Project::MSG_VERBOSE
);
return false;
}
/**
* Prepares the command building and execution, i.e.
* changes to the specified directory.
*
* @throws BuildException
* @return void
*/
protected function prepare()
{
if ($this->dir === null) {
return;
}
// expand any symbolic links first
if (!$this->dir->getCanonicalFile()->isDirectory()) {
throw new BuildException(
"'" . (string) $this->dir . "' is not a valid directory"
);
}
$this->currdir = getcwd();
@chdir($this->dir->getPath());
}
/**
* Builds the full command to execute and stores it in $command.
*
* @throws BuildException
* @return void
* @uses $command
*/
protected function buildCommand()
{
if ($this->command === null && $this->commandline->getExecutable() === null) {
throw new BuildException(
'ExecTask: Please provide "command" OR "executable"'
);
} else {
if ($this->command === null) {
$this->realCommand = Commandline::toString($this->commandline->getCommandline(), $this->escape);
} else {
if ($this->commandline->getExecutable() === null) {
$this->realCommand = $this->command;
//we need to escape the command only if it's specified directly
// commandline takes care of "executable" already
if ($this->escape == true) {
$this->realCommand = escapeshellcmd($this->realCommand);
}
} else {
throw new BuildException(
'ExecTask: Either use "command" OR "executable"'
);
}
}
}
if ($this->error !== null) {
$this->realCommand .= ' 2> ' . escapeshellarg($this->error->getPath());
$this->log(
"Writing error output to: " . $this->error->getPath(),
$this->logLevel
);
}
if ($this->output !== null) {
$this->realCommand .= ' 1> ' . escapeshellarg($this->output->getPath());
$this->log(
"Writing standard output to: " . $this->output->getPath(),
$this->logLevel
);
} elseif ($this->spawn) {
$this->realCommand .= ' 1>/dev/null';
$this->log("Sending output to /dev/null", $this->logLevel);
}
// If neither output nor error are being written to file
// then we'll redirect error to stdout so that we can dump
// it to screen below.
if ($this->output === null && $this->error === null && $this->passthru === false) {
$this->realCommand .= ' 2>&1';
}
// we ignore the spawn boolean for windows
if ($this->spawn) {
$this->realCommand .= ' &';
}
}
/**
* Executes the command and returns return code and output.
*
* @return array array(return code, array with output)
*/
protected function executeCommand()
{
$this->log("Executing command: " . $this->realCommand, $this->logLevel);
$output = array();
$return = null;
if ($this->passthru) {
passthru($this->realCommand, $return);
} else {
exec($this->realCommand, $output, $return);
}
return array($return, $output);
}
/**
* Runs all tasks after command execution:
* - change working directory back
* - log output
* - verify return value
*
* @param integer $return Return code
* @param array $output Array with command output
*
* @throws BuildException
* @return void
*/
protected function cleanup($return, $output)
{
if ($this->dir !== null) {
@chdir($this->currdir);
}
$outloglevel = $this->logOutput ? Project::MSG_INFO : Project::MSG_VERBOSE;
foreach ($output as $line) {
$this->log($line, $outloglevel);
}
if ($this->returnProperty) {
$this->project->setProperty($this->returnProperty, $return);
}
if ($this->outputProperty) {
$this->project->setProperty(
$this->outputProperty,
implode("\n", $output)
);
}
$this->setExitValue($return);
if ($return != 0 && $this->checkreturn) {
throw new BuildException("Task exited with code $return");
}
}
/**
* Set the exit value.
*
* @param int $value exit value of the process.
*/
protected function setExitValue($value)
{
$this->exitValue = $value;
}
/**
* Query the exit value of the process.
*
* @return int the exit value or self::INVALID if no exit value has
* been received.
*/
public function getExitValue()
{
return $this->exitValue;
}
/**
* The command to use.
*
* @param mixed $command String or string-compatible (e.g. w/ __toString()).
*
* @return void
*/
public function setCommand($command)
{
$this->command = "" . $command;
}
/**
* The executable to use.
*
* @param mixed $executable String or string-compatible (e.g. w/ __toString()).
*
* @return void
*/
public function setExecutable($executable)
{
$this->commandline->setExecutable((string) $executable);
}
/**
* Whether to use escapeshellcmd() to escape command.
*
* @param boolean $escape If the command shall be escaped or not
*
* @return void
*/
public function setEscape($escape)
{
$this->escape = (bool) $escape;
}
/**
* Specify the working directory for executing this command.
*
* @param PhingFile $dir Working directory
*
* @return void
*/
public function setDir(PhingFile $dir)
{
$this->dir = $dir;
}
/**
* Specify OS (or multiple OS) that must match in order to execute this command.
*
* @param string $os Operating system string (e.g. "Linux")
*
* @return void
*/
public function setOs($os)
{
$this->os = (string) $os;
}
/**
* File to which output should be written.
*
* @param PhingFile $f Output log file
*
* @return void
*/
public function setOutput(PhingFile $f)
{
$this->output = $f;
}
/**
* File to which error output should be written.
*
* @param PhingFile $f Error log file
*
* @return void
*/
public function setError(PhingFile $f)
{
$this->error = $f;
}
/**
* Whether to use PHP's passthru() function instead of exec()
*
* @param boolean $passthru If passthru shall be used
*
* @return void
*/
public function setPassthru($passthru)
{
$this->passthru = (bool) $passthru;
}
/**
* Whether to log returned output as MSG_INFO instead of MSG_VERBOSE
*
* @param boolean $logOutput If output shall be logged visibly
*
* @return void
*/
public function setLogoutput($logOutput)
{
$this->logOutput = (bool) $logOutput;
}
/**
* Whether to suppress all output and run in the background.
*
* @param boolean $spawn If the command is to be run in the background
*
* @return void
*/
public function setSpawn($spawn)
{
$this->spawn = (bool) $spawn;
}
/**
* Whether to check the return code.
*
* @param boolean $checkreturn If the return code shall be checked
*
* @return void
*/
public function setCheckreturn($checkreturn)
{
$this->checkreturn = (bool) $checkreturn;
}
/**
* The name of property to set to return value from exec() call.
*
* @param string $prop Property name
*
* @return void
*/
public function setReturnProperty($prop)
{
$this->returnProperty = $prop;
}
/**
* The name of property to set to output value from exec() call.
*
* @param string $prop Property name
*
* @return void
*/
public function setOutputProperty($prop)
{
$this->outputProperty = $prop;
}
/**
* Set level of log messages generated (default = verbose)
*
* @param string $level Log level
*
* @throws BuildException
* @return void
*/
public function setLevel($level)
{
switch ($level) {
case 'error':
$this->logLevel = Project::MSG_ERR;
break;
case 'warning':
$this->logLevel = Project::MSG_WARN;
break;
case 'info':
$this->logLevel = Project::MSG_INFO;
break;
case 'verbose':
$this->logLevel = Project::MSG_VERBOSE;
break;
case 'debug':
$this->logLevel = Project::MSG_DEBUG;
break;
default:
throw new BuildException(
sprintf('Unknown log level "%s"', $level)
);
}
}
/**
* Creates a nested tag.
*
* @return CommandlineArgument Argument object
*/
public function createArg()
{
return $this->commandline->createArgument();
}
}
phing-2.14.0/tasks/system/SequentialTask.php 0000664 0001750 0001750 00000003754 12670364674 020662 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/TaskContainer.php';
/**
* Sequential is a container task that contains other Phing Task objects.
*
* The sequential task has no attributes and does not support any nested
* elements apart from Ant tasks. Any valid Ant task may be embedded within the
* sequential task.
*
* @since 2.1.2
* @package phing.tasks.system
*/
class SequentialTask extends Task implements TaskContainer
{
/** Optional Vector holding the nested tasks */
protected $nestedTasks = array();
/**
* Add a nested task to Sequential.
* @param Task $nestedTask Nested task to execute Sequential
*/
public function addTask(Task $nestedTask)
{
$this->nestedTasks[] = $nestedTask;
}
/**
* Execute all nestedTasks.
* @throws BuildException if one of the nested tasks fails.
*/
public function main()
{
foreach ($this->nestedTasks as $task) {
$task->perform();
}
}
}
phing-2.14.0/tasks/system/AppendTask.php 0000775 0001750 0001750 00000021755 12670364674 017763 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
include_once 'phing/types/FileList.php';
include_once 'phing/types/FileSet.php';
/**
* Appends text, contents of a file or set of files defined by a filelist to a destination file.
*
*
*
*
* OR
*
*
*
*
*
* OR
*
*
*
*
*
*
*
*
*
*
*
* @package phing.tasks.system
* @version $Id: 961194f791a995c147f1181bf9df22fb25ced766 $
*/
class AppendTask extends Task
{
/** Append stuff to this file. */
private $to;
/** Explicit file to append. */
private $file;
/** Any filesets of files that should be appended. */
private $filesets = array();
/** Any filelists of files that should be appended. */
private $filelists = array();
/** Any filters to be applied before append happens. */
private $filterChains = array();
/** Text to append. (cannot be used in conjunction w/ files or filesets) */
private $text;
/** Sets specific file to append.
* @param PhingFile $f
*/
public function setFile(PhingFile $f)
{
$this->file = $f;
}
/**
* Set target file to append to.
*
* @deprecated Will be removed with final release.
*
* @param PhingFile $f
*
* @return void
*/
public function setTo(PhingFile $f)
{
$this->log(
"The 'to' attribute is deprecated in favor of 'destFile'; please update your code.",
Project::MSG_WARN
);
$this->to = $f;
}
/**
* The more conventional naming for method to set destination file.
*
* @param PhingFile $f
*
* @return void
*/
public function setDestFile(PhingFile $f)
{
$this->to = $f;
}
/**
* Supports embedded element.
*
* @return FileList
*/
public function createFileList()
{
$num = array_push($this->filelists, new FileList());
return $this->filelists[$num - 1];
}
/**
* Nested adder, adds a set of files (nested fileset attribute).
*
* @param FileSet $fs
*
* @return void
*/
public function addFileSet(FileSet $fs)
{
$this->filesets[] = $fs;
}
/**
* Creates a filterchain
*
* @return FilterChain The created filterchain object
*/
public function createFilterChain()
{
$num = array_push($this->filterChains, new FilterChain($this->project));
return $this->filterChains[$num - 1];
}
/**
* Sets text to append. (cannot be used in conjunction w/ files or filesets).
*
* @param string $txt
*
* @return void
*/
public function setText($txt)
{
$this->text = (string) $txt;
}
/**
* Sets text to append. Supports CDATA.
*
* @param string $txt
*
* @return void
*/
public function addText($txt)
{
$this->text = (string) $txt;
}
/**
* Append the file(s).
*
* {@inheritdoc}
*/
public function main()
{
if ($this->to === null) {
throw new BuildException("You must specify the 'destFile' attribute");
}
if ($this->file === null && empty($this->filelists) && empty($this->filesets) && $this->text === null) {
throw new BuildException("You must specify a file, use a filelist, or specify a text value.");
}
if ($this->text !== null && ($this->file !== null || !empty($this->filelists))) {
throw new BuildException("Cannot use text attribute in conjunction with file or filelists.");
}
// create a filwriter to append to "to" file.
$writer = new FileWriter($this->to, $append = true);
if ($this->text !== null) {
// simply append the text
$this->log("Appending string to " . $this->to->getPath());
// for debugging primarily, maybe comment
// out for better performance(?)
$lines = explode("\n", $this->text);
foreach ($lines as $line) {
$this->log($line, Project::MSG_VERBOSE);
}
$writer->write($this->text);
} else {
// append explicitly-specified file
if ($this->file !== null) {
try {
$this->appendFile($writer, $this->file);
} catch (Exception $ioe) {
$this->log(
"Unable to append contents of file " . $this->file->getAbsolutePath() . ": " . $ioe->getMessage(
),
Project::MSG_WARN
);
}
}
// append the files in the filelists
foreach ($this->filelists as $fl) {
try {
$files = $fl->getFiles($this->project);
$this->appendFiles($writer, $files, $fl->getDir($this->project));
} catch (BuildException $be) {
$this->log($be->getMessage(), Project::MSG_WARN);
}
}
// append any files in filesets
foreach ($this->filesets as $fs) {
try {
$files = $fs->getDirectoryScanner($this->project)->getIncludedFiles();
$this->appendFiles($writer, $files, $fs->getDir($this->project));
} catch (BuildException $be) {
$this->log($be->getMessage(), Project::MSG_WARN);
}
}
} // if ($text) {} else {}
$writer->close();
}
/**
* Append an array of files in a directory.
*
* @param FileWriter $writer The FileWriter that is appending to target file.
* @param array $files array of files to delete; can be of zero length
* @param PhingFile $dir directory to work from
*
* @return void
*/
private function appendFiles(FileWriter $writer, $files, PhingFile $dir)
{
if (!empty($files)) {
$this->log(
"Attempting to append " . count(
$files
) . " files" . ($dir !== null ? ", using basedir " . $dir->getPath() : "")
);
$basenameSlot = Register::getSlot("task.append.current_file");
$pathSlot = Register::getSlot("task.append.current_file.path");
foreach ($files as $filename) {
try {
$f = new PhingFile($dir, $filename);
$basenameSlot->setValue($filename);
$pathSlot->setValue($f->getPath());
$this->appendFile($writer, $f);
} catch (Exception $ioe) {
$this->log(
"Unable to append contents of file " . $f->getAbsolutePath() . ": " . $ioe->getMessage(),
Project::MSG_WARN
);
}
}
} // if !empty
}
/**
* @param FileWriter $writer
* @param PhingFile $f
*
* @return void
*/
private function appendFile(FileWriter $writer, PhingFile $f)
{
$in = FileUtils::getChainedReader(new FileReader($f), $this->filterChains, $this->project);
while (-1 !== ($buffer = $in->read())) { // -1 indicates EOF
$writer->write($buffer);
}
$this->log("Appending contents of " . $f->getPath() . " to " . $this->to->getPath());
}
}
phing-2.14.0/tasks/system/Dirname.php 0000664 0001750 0001750 00000005361 12670364674 017300 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/system/io/PhingFile.php';
require_once 'phing/BuildException.php';
/**
* Determines the directory name of the specified file.
*
* This task can accept the following attributes:
*
* Both file and property are required.
*
* When this task executes, it will set the specified property to the
* value of the specified file up to, but not including, the last path
* element. If file is a file, the directory will be the current
* directory.
*
* @author Siad Ardroumli
* @package phing.tasks.system
*/
class Dirname extends Task
{
/** @var PhingFile $file */
private $file;
private $property;
/**
* Path to take the dirname of.
* @param string|PhingFile file a File value
*/
public function setFile($file)
{
if ($file instanceof PhingFile) {
$this->file = $file;
} else {
$this->file = new PhingFile($file);
}
}
/**
* The name of the property to set.
* @param string $property the name of the property
*/
public function setProperty($property)
{
$this->property = $property;
}
/**
* Execute this task.
* @throws BuildException on error
*/
public function main()
{
if ($this->property == null) {
throw new BuildException("property attribute required", $this->getLocation());
}
if ($this->file == null) {
throw new BuildException("file attribute required", $this->getLocation());
} else {
$value = $this->file->getAbsoluteFile()->getParent();
$this->getProject()->setNewProperty($this->property, $value);
}
}
}
phing-2.14.0/tasks/system/WaitForTask.php 0000775 0001750 0001750 00000013414 12670364674 020120 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* Based on Apache Ant Wait For:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @author Michiel Rook
* @version $Id: a2207ec35496db9f3ad2a15a780bb2ec26cf04f0 $
* @package phing.tasks.system
*/
class WaitForTask extends ConditionBase
{
const ONE_MILLISECOND = 1;
const ONE_SECOND = 1000;
const ONE_MINUTE = 60000;
const ONE_HOUR = 3600000;
const ONE_DAY = 86400000;
const ONE_WEEK = 604800000;
const DEFAULT_MAX_WAIT_MILLIS = 180000;
const DEFAULT_CHECK_MILLIS = 500;
protected $maxWait = self::DEFAULT_MAX_WAIT_MILLIS;
protected $maxWaitMultiplier = self::ONE_MILLISECOND;
protected $checkEvery = self::DEFAULT_CHECK_MILLIS;
protected $checkEveryMultiplier = self::ONE_MILLISECOND;
protected $timeoutProperty = null;
/**
* Set the maximum length of time to wait.
* @param int $maxWait
*/
public function setMaxWait($maxWait)
{
$this->maxWait = (int) $maxWait;
}
/**
* Set the max wait time unit
* @param string $maxWaitUnit
*/
public function setMaxWaitUnit($maxWaitUnit)
{
$this->maxWaitMultiplier = $this->_convertUnit($maxWaitUnit);
}
/**
* Set the time between each check
* @param int $checkEvery
*/
public function setCheckEvery($checkEvery)
{
$this->checkEvery = (int) $checkEvery;
}
/**
* Set the check every time unit
* @param string $checkEveryUnit
* @return void
*/
public function setCheckEveryUnit($checkEveryUnit)
{
$this->checkEveryMultiplier = $this->_convertUnit($checkEveryUnit);
}
/**
* Name of the property to set after a timeout.
* @param string $timeoutProperty
* @return void
*/
public function setTimeoutProperty($timeoutProperty)
{
$this->timeoutProperty = $timeoutProperty;
}
/**
* Convert the unit to a multipler.
* @param string $unit
* @throws BuildException
* @return int
*/
protected function _convertUnit($unit)
{
switch ($unit) {
case "week":
{
return self::ONE_WEEK;
}
case "day":
{
return self::ONE_DAY;
}
case "hour":
{
return self::ONE_HOUR;
}
case "minute":
{
return self::ONE_MINUTE;
}
case "second":
{
return self::ONE_SECOND;
}
case "millisecond":
{
return self::ONE_MILLISECOND;
}
default:
{
throw new BuildException("Illegal unit '$unit'");
}
}
}
/**
* Check repeatedly for the specified conditions until they become
* true or the timeout expires.
* @throws BuildException
*/
public function main()
{
if ($this->countConditions() > 1) {
throw new BuildException("You must not nest more than one condition into ");
}
if ($this->countConditions() < 1) {
throw new BuildException("You must nest a condition into ");
}
$cs = $this->getIterator();
$condition = $cs->current();
$maxWaitMillis = $this->maxWait * $this->maxWaitMultiplier;
$checkEveryMillis = $this->checkEvery * $this->checkEveryMultiplier;
$start = microtime(true) * 1000;
$end = $start + $maxWaitMillis;
while (microtime(true) * 1000 < $end) {
if ($condition->evaluate()) {
$this->log("waitfor: condition was met", Project::MSG_VERBOSE);
return;
}
usleep($checkEveryMillis * 1000);
}
$this->log("waitfor: timeout", Project::MSG_VERBOSE);
if ($this->timeoutProperty != null) {
$this->project->setNewProperty($this->timeoutProperty, "true");
}
}
}
phing-2.14.0/tasks/system/TaskdefTask.php 0000775 0001750 0001750 00000012555 12670364674 020133 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
include_once 'phing/system/io/PhingFile.php';
/**
* Register a task for use within a buildfile.
*
* This is for registering your own tasks -- or any non-core Task -- for use within a buildfile.
* If you find that you are using a particular class frequently, you may want to edit the
* phing/tasks/defaults.properties file so that it is included by default. You may also
* want to submit it (if LGPL or compatible license) to be included in Phing distribution.
*
*
*
* .
* .
*
*
*
* TODO:
* -- possibly refactor since this is almost the same as TypeDefTask
* (right now these are just too simple to really justify creating an abstract class)
*
* @author Hans Lellelid
* @version $Id: b554ecb4f867f8ccbcd764de62482d6c16800c00 $
* @package phing.tasks.system
*/
class TaskdefTask extends Task
{
/** Tag name for task that will be used in XML */
private $name;
/**
* Classname of task to register.
* This can be a dot-path -- relative to a location on PHP include_path.
* E.g. path.to.MyClass -> path/to/MyClass.php
* @var string
*/
private $classname;
/**
* Path to add to PHP include_path to aid in finding specified class.
* @var Path
*/
private $classpath;
/**
* Refid to already defined classpath
*/
private $classpathId;
/**
* Name of file to load multiple definitions from.
* @var string
*/
private $typeFile;
/**
* Set the classpath to be used when searching for component being defined
*
* @param Path $classpath A Path object containing the classpath.
*/
public function setClasspath(Path $classpath)
{
if ($this->classpath === null) {
$this->classpath = $classpath;
} else {
$this->classpath->append($classpath);
}
}
/**
* Create the classpath to be used when searching for component being defined
*
* @return Path
*/
public function createClasspath()
{
if ($this->classpath === null) {
$this->classpath = new Path($this->project);
}
return $this->classpath->createPath();
}
/**
* Reference to a classpath to use when loading the files.
* @param Reference $r
*/
public function setClasspathRef(Reference $r)
{
$this->classpathId = $r->getRefId();
$this->createClasspath()->setRefid($r);
}
/**
* Sets the name that will be used in XML buildfile.
* @param string $name
*/
public function setName($name)
{
$this->name = $name;
}
/**
* Sets the class name / dotpath to use.
* @param string $class
*/
public function setClassname($class)
{
$this->classname = $class;
}
/**
* Sets the file of definitionas to use to use.
* @param string $file
*/
public function setFile($file)
{
$this->typeFile = $file;
}
/** Main entry point */
public function main()
{
if ($this->typeFile === null &&
($this->name === null || $this->classname === null)
) {
throw new BuildException("You must specify name and class attributes for .");
}
if ($this->typeFile == null) {
$this->log("Task " . $this->name . " will be handled by class " . $this->classname, Project::MSG_VERBOSE);
$this->project->addTaskDefinition($this->name, $this->classname, $this->classpath);
} else {
try { // try to load taskdefs given in file
$props = new Properties();
$in = new PhingFile((string) $this->typeFile);
if ($in === null) {
throw new BuildException("Can't load task list {$this->typeFile}");
}
$props->load($in);
$enum = $props->propertyNames();
foreach ($enum as $key) {
$value = $props->getProperty($key);
$this->project->addTaskDefinition($key, $value, $this->classpath);
}
} catch (IOException $ioe) {
throw new BuildException("Can't load task list {$this->typeFile}");
}
}
}
}
phing-2.14.0/tasks/ext/NotifySendTask.php 0000664 0001750 0001750 00000006710 12670364674 020101 0 ustar michiel michiel
* @license LGPL (see http://www.gnu.org/licenses/lgpl.html)
* @link https://github.com/kenguest/Phing-NotifySendTask
*/
require_once 'phing/Task.php';
/**
* NotifySendTask
*
* @category Tasks
* @package phing.tasks.ext
* @author Ken Guest
* @license LGPL (see http://www.gnu.org/licenses/lgpl.html)
* @link NotifySendTask.php
*/
class NotifySendTask extends Task
{
protected $msg = null;
protected $title = null;
protected $icon = 'info';
protected $silent = false;
/**
* Set icon attribute
*
* @param string $icon name/location of icon
*
* @return void
*/
public function setIcon($icon)
{
switch ($icon)
{
case 'info':
case 'error':
case 'warning':
$this->icon = $icon;
break;
default:
if (file_exists($icon) && is_file($icon)) {
$this->icon = $icon;
} else {
if (isset($this->log)) {
$this->log(
sprintf(
"%s is not a file. Using default icon instead.",
$icon
),
Project::MSG_WARN
);
}
}
}
}
/**
* Get icon to be used (filename or generic name)
*
* @return string
*/
public function getIcon()
{
return $this->icon;
}
/**
* Set to a true value to not execute notifysend command.
*
* @param bool $silent Don't execute notifysend? True not to.
*
* @return void
*/
public function setSilent($silent)
{
$this->silent = (bool) $silent;
}
/**
* Set title attribute
*
* @param string $title Title to display
*
* @return void
*/
public function setTitle($title)
{
$this->title = $title;
}
/**
* Get Title
*
* @return string
*/
public function getTitle()
{
return $this->title;
}
/**
* Set msg attribute
*
* @param string $msg Message
*
* @return void
*/
public function setMsg($msg)
{
$this->msg = $msg;
}
/**
* Get message.
*
* @return string
*/
public function getMsg()
{
return $this->msg;
}
/**
* The main entry point method.
*
* @throws BuildException
* @return void
*/
public function main()
{
$msg = '';
$title = 'Phing';
if ($this->title != '') {
$title = "'" . $this->title . "'";
}
if ($this->msg != '') {
$msg = "'" . $this->msg . "'";
}
$cmd = 'notify-send -i ' . $this->icon . ' ' . $title . ' ' . $msg;
$this->log(sprintf("cmd: %s", $cmd), Project::MSG_DEBUG);
if (!$this->silent) {
exec(escapeshellcmd($cmd), $output, $return);
if ($return !== 0) {
throw new BuildException("Notify task failed.");
}
}
$this->log(sprintf("Title: '%s'", $title), Project::MSG_DEBUG);
$this->log(sprintf("Message: '%s'", $msg), Project::MSG_DEBUG);
$this->log($msg, Project::MSG_INFO);
}
}
// vim:set et ts=4 sw=4:
phing-2.14.0/tasks/ext/ParallelTask.php 0000775 0001750 0001750 00000005535 12670364674 017562 0 ustar michiel michiel .
*
* @package phing.tasks.ext
*/
/**
* Uses the DocBlox_Parallel library to run nested Phing tasks concurrently.
*
* WARNING: this task is highly experimental!
*
* @author Michiel Rook
* @version $Id: aec45bda16dccf81c18561f29f4923bc94fae280 $
* @package phing.tasks.ext
* @see https://github.com/phpdocumentor/Parallel
* @since 2.4.10
*/
class ParallelTask extends SequentialTask
{
/**
* Maximum number of threads / processes
* @var int
*/
private $threadCount = 2;
/**
* Sets the maximum number of threads / processes to use
* @param int $threadCount
*/
public function setThreadCount($threadCount)
{
$this->threadCount = $threadCount;
}
public function init()
{
}
public function main()
{
@include_once 'phing/contrib/DocBlox/Parallel/Manager.php';
@include_once 'phing/contrib/DocBlox/Parallel/Worker.php';
@include_once 'phing/contrib/DocBlox/Parallel/WorkerPipe.php';
if (!class_exists('DocBlox_Parallel_Worker')) {
throw new BuildException(
'ParallelTask depends on DocBlox being installed and on include_path.',
$this->getLocation()
);
}
$mgr = new DocBlox_Parallel_Manager();
$mgr->setProcessLimit($this->threadCount);
foreach ($this->nestedTasks as $task) {
$worker = new DocBlox_Parallel_Worker(
array($task, 'perform'),
array($task)
);
$mgr->addWorker($worker);
}
$mgr->execute();
/** @var DocBlox_Parallel_Worker $nestedTask */
foreach ($mgr as $nestedTask) {
if ($nestedTask->getError() === "") {
continue;
}
throw new BuildException($nestedTask->getError());
}
}
}
phing-2.14.0/tasks/ext/HttpRequestTask.php 0000664 0001750 0001750 00000012415 12670364674 020306 0 ustar michiel michiel .
*/
require_once 'phing/tasks/ext/HttpTask.php';
/**
* A HTTP request task.
* Making an HTTP request and try to match the response against an provided
* regular expression.
*
* @package phing.tasks.ext
* @author Benjamin Schultz
* @version $Id: ab6a2d3903492a67c2a16f15ae667d8866af6c1e $
* @since 2.4.1
*/
class HttpRequestTask extends HttpTask
{
/**
* Holds the regular expression that should match the response
*
* @var string
*/
protected $responseRegex = '';
/**
* Whether to enable detailed logging
*
* @var boolean
*/
protected $verbose = false;
/**
* Holds the events that will be logged
*
* @var array
*/
protected $observerEvents = array(
'connect',
'sentHeaders',
'sentBodyPart',
'receivedHeaders',
'receivedBody',
'disconnect',
);
/**
* Holds the request method
*
* @var string
*/
protected $method = null;
/**
* Holds additional post parameters for the request
*
* @var Parameter[]
*/
protected $postParameters = array();
/**
* Sets the response regex
*
* @param string $regex
*/
public function setResponseRegex($regex)
{
$this->responseRegex = $regex;
}
/**
* Sets whether to enable detailed logging
*
* @param boolean $verbose
*/
public function setVerbose($verbose)
{
$this->verbose = StringHelper::booleanValue($verbose);
}
/**
* Sets a list of observer events that will be logged if verbose output is enabled.
*
* @param string $observerEvents List of observer events
*/
public function setObserverEvents($observerEvents)
{
$this->observerEvents = array();
$token = ' ,;';
$ext = strtok($observerEvents, $token);
while ($ext !== false) {
$this->observerEvents[] = $ext;
$ext = strtok($token);
}
}
/**
* The setter for the method
* @param $method
*/
public function setMethod($method)
{
$this->method = $method;
}
/**
* Creates post body parameters for this request
*
* @return Parameter The created post parameter
*/
public function createPostParameter()
{
$num = array_push($this->postParameters, new Parameter());
return $this->postParameters[$num - 1];
}
/**
* Load the necessary environment for running this task.
*
* @throws BuildException
*/
public function init()
{
parent::init();
$this->authScheme = HTTP_Request2::AUTH_BASIC;
// Other dependencies that should only be loaded when class is actually used
require_once 'HTTP/Request2/Observer/Log.php';
}
/**
* Creates and configures an instance of HTTP_Request2
*
* @return HTTP_Request2
*/
protected function createRequest()
{
$request = parent::createRequest();
if ($this->method == HTTP_Request2::METHOD_POST) {
$request->setMethod(HTTP_Request2::METHOD_POST);
foreach ($this->postParameters as $postParameter) {
$request->addPostParameter($postParameter->getName(), $postParameter->getValue());
}
}
if ($this->verbose) {
$observer = new HTTP_Request2_Observer_Log();
// set the events we want to log
$observer->events = $this->observerEvents;
$request->attach($observer);
}
return $request;
}
/**
* Checks whether response body matches the given regexp
*
* @param HTTP_Request2_Response $response
* @return void
* @throws BuildException
*/
protected function processResponse(HTTP_Request2_Response $response)
{
if ($this->responseRegex !== '') {
$matches = array();
preg_match($this->responseRegex, $response->getBody(), $matches);
if (count($matches) === 0) {
throw new BuildException('The received response body did not match the given regular expression');
} else {
$this->log('The response body matched the provided regex.');
}
}
}
}
phing-2.14.0/tasks/ext/phk/PhkPackageWebAccess.php 0000664 0001750 0001750 00000003266 12670364674 021537 0 ustar michiel michiel .
*/
require_once 'phing/tasks/ext/phk/PhkPackageWebAccessPath.php';
/**
* @author Alexey Shockov
* @package phing.tasks.ext.phk
*/
class PhkPackageWebAccess
{
/**
* @var array
*/
private $paths = array();
/**
* @return PhkPackageWebAccessPath
*/
public function createPath()
{
return ($this->paths[] = new PhkPackageWebAccessPath());
}
/**
* @return array
*/
public function getPaths()
{
/*
* Get real paths...
*/
$paths = array();
foreach ($this->paths as $path) {
$paths[] = $path->getPath();
}
return $paths;
}
}
phing-2.14.0/tasks/ext/phk/PhkPackageTask.php 0000664 0001750 0001750 00000014465 12670364674 020605 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/phk/PhkPackageWebAccess.php';
/**
* See {@link http://phk.tekwire.net/} for more information about PHK.
*
* @author Alexey Shockov
* @package phing.tasks.ext.phk
*/
class PhkPackageTask extends Task
{
/**
* @var string
*/
private $outputFile;
/**
* @var string
*/
private $inputDirectory;
/**
* @var string
*/
private $phkCreatorPath;
/**
* @var PhkPackageWebAccess
*/
private $webAccess;
/**
* @var array
*/
private $modifiers = array();
/**
* @var array
*/
private $options = array();
/**
* @return PhkPackageWebAccess
*/
public function createWebAccess()
{
return ($this->webAccess = new PhkPackageWebAccess());
}
/**
* @param string $crcCheck
*/
public function setCrcCheck($crcCheck)
{
$this->options['crc_check'] = ('true' == $crcCheck ? true : false);
}
/**
* @param string $webRunScript
*/
public function setWebRunScript($webRunScript)
{
$this->options['web_run_script'] = $webRunScript;
}
/**
* @param string $cliRunScript
*/
public function setCliRunScript($cliRunScript)
{
$this->options['cli_run_script'] = $cliRunScript;
}
/**
* @param string $libRunScript
*/
public function setLibRunScript($libRunScript)
{
$this->options['lib_run_script'] = $libRunScript;
}
/**
* @param string $name
*/
public function setName($name)
{
$this->options['name'] = $name;
}
/**
* @param string $webMainRedirect
*/
public function setWebMainRedirect($webMainRedirect)
{
$this->options['web_main_redirect'] = ('true' == $webMainRedirect ? true : false);
}
/**
* @param string $pluginClass
*/
public function setPluginClass($pluginClass)
{
$this->options['plugin_class'] = $pluginClass;
}
/**
* @param string $version
*/
public function setVersion($version)
{
$this->options['version'] = $version;
}
/**
* @param string $summary
*/
public function setSummary($summary)
{
$this->options['summary'] = $summary;
}
/**
* @param string $inputDirectory
*/
public function setInputDirectory($inputDirectory)
{
$this->inputDirectory = $inputDirectory;
}
/**
* @param string $outputFile
*/
public function setOutputFile($outputFile)
{
$this->outputFile = $outputFile;
}
/**
* May be none, gzip or bzip2.
*
* @param string $compress
*/
public function setCompress($compress)
{
$this->modifiers['compress'] = $compress;
}
/**
* True or false.
*
* @param srting $strip
*/
public function setStrip($strip)
{
$this->modifiers['strip'] = $strip;
}
/**
* Path to PHK_Creator.phk file.
*
* @param srting $path
*/
public function setPhkCreatorPath($path)
{
$this->phkCreatorPath = $path;
}
/**
*
*/
public function init()
{
}
/**
* Main method...
*/
public function main()
{
/*
* Check for empty first - speed ;)
*/
if (!is_file($this->phkCreatorPath)) {
throw new BuildException('You must specify the "phkcreatorpath" attribute for PHK task.');
}
if (empty($this->inputDirectory)) {
throw new BuildException('You must specify the "inputdirectory" attribute for PHK task.');
}
if (empty($this->outputFile)) {
throw new BuildException('You must specify the "outputfile" attribute for PHK task.');
}
require_once $this->phkCreatorPath;
$mountPoint = PHK_Mgr::mount($this->outputFile, PHK::F_CREATOR);
$phkManager = PHK_Mgr::instance($mountPoint);
/*
* Add files.
*/
$phkManager->ftree()->merge_file_tree('/', $this->inputDirectory, $this->modifiers);
/*
* Add web_access to options, if present.
*/
if (!is_null($this->webAccess)) {
$webAccessPaths = $this->webAccess->getPaths();
if (!empty($webAccessPaths)) {
$this->options['web_access'] = $webAccessPaths;
}
}
$phkManager->set_options($this->options);
/*
* Intercept output (in PHP we can't intercept stream).
*/
ob_start();
/*
* Create file...
*/
$phkManager->dump();
/*
* Print with Phing log...
*/
$output = trim(ob_get_clean());
$output = explode("\n", $output);
foreach ($output as $line) {
/*
* Delete all '--- *' lines. Bluh!
*/
/*
* TODO Change preg_math to more faster alternative.
*/
if (preg_match('/^---/', $line)) {
continue;
}
$this->log($line);
}
/*
* Set rights for generated file... Don't use umask() - see
* notes in official documentation for this function.
*/
chmod($this->outputFile, 0644);
}
}
phing-2.14.0/tasks/ext/phk/PhkPackageWebAccessPath.php 0000664 0001750 0001750 00000002637 12670364674 022355 0 ustar michiel michiel .
*/
/**
* @author Alexey Shockov
* @package phing.tasks.ext.phk
*/
class PhkPackageWebAccessPath
{
/**
* @var string
*/
private $path;
/**
* @param string $path
*/
public function addText($path)
{
$this->path = trim($path);
}
/**
* @return string
*/
public function getPath()
{
return $this->path;
}
}
phing-2.14.0/tasks/ext/dbdeploy/DbmsSyntax.php 0000775 0001750 0001750 00000002643 12670364674 021076 0 ustar michiel michiel .
*/
/**
* Utility class for generating necessary server-specific SQL commands
*
* @author Luke Crouch at SourceForge (http://sourceforge.net)
* @version $Id: e8f266768b58a63d2f0a4a40e1c4c220b81901ec $
* @package phing.tasks.ext.dbdeploy
*/
abstract class DbmsSyntax
{
/**
* @param $db
*/
public function applyAttributes($db)
{
}
abstract public function generateTimestamp();
}
phing-2.14.0/tasks/ext/dbdeploy/DbmsSyntaxOracle.php 0000775 0001750 0001750 00000003144 12670364674 022221 0 ustar michiel michiel .
*/
/**
* Utility class for generating necessary server-specific SQL commands
*
* @author Luke Crouch at SourceForge (http://sourceforge.net)
* @version $Id: adc9b31780df2145519b4d451cb462527bd200f5 $
* @package phing.tasks.ext.dbdeploy
*/
class DbmsSyntaxOracle extends DbmsSyntax
{
/**
* @param $db
*/
public function applyAttributes($db)
{
$db->setAttribute(PDO::ATTR_CASE, PDO::CASE_LOWER);
}
/**
* @return string
*/
public function generateTimestamp()
{
return "(sysdate - to_date('01-JAN-1970','DD-MON-YYYY')) * (86400)";
}
}
phing-2.14.0/tasks/ext/dbdeploy/DbDeployTask.php 0000775 0001750 0001750 00000031777 12670364674 021341 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/dbdeploy/DbmsSyntaxFactory.php';
/**
* Generate SQL script for db using dbdeploy schema version table
* and delta scripts
*
*
*
* @author Luke Crouch at SourceForge (http://sourceforge.net)
* @version $Id: 2800e23b0fecfddc209dec5c7985e0c8eace0959 $
* @package phing.tasks.ext.dbdeploy
*/
class DbDeployTask extends Task
{
/**
* The tablename to use from the database for storing all changes
* This cannot be changed
*
* @var string
*/
public static $TABLE_NAME = 'changelog';
/**
* Connection string for the database connection
*
* @var string
*/
protected $url;
/**
* The userid for the database connection
*
* @var string
*/
protected $userid;
/**
* The password of the database user
*
* @var string
*/
protected $password;
/**
* Path to the directory that holds the database patch files
*
* @var string
*/
protected $dir;
/**
* Output file for performing all database patches of this deployment
* Contains all the SQL statements that need to be executed
*
* @var string
*/
protected $outputFile = 'dbdeploy_deploy.sql';
/**
* Outputfile for undoing the database patches of this deployment
* Contains all the SQL statements that need to be executed
*
* @var string
*/
protected $undoOutputFile = 'dbdeploy_undo.sql';
/**
* The deltaset that's being used
*
* @var string
*/
protected $deltaSet = 'Main';
/**
* The number of the last change to apply
*
* @var int
*/
protected $lastChangeToApply = 999;
/**
* Contains the object for the DBMS that is used
*
* @var object
*/
protected $dbmsSyntax = null;
/**
* Array with all change numbers that are applied already
*
* @var array
*/
protected $appliedChangeNumbers = array();
/**
* Checkall attribute
* False means dbdeploy will only apply patches that have a higher number
* than the last patchnumber that was applied
* True means dbdeploy will apply all changes that aren't applied
* already (in ascending order)
*
* @var int
*/
protected $checkall = false;
/**
* The value of the 'applied_by' column for
* each changelog entry
*
* @var string
*/
protected $appliedBy = 'dbdeploy';
/**
* The main function for the task
*
* @throws BuildException
* @return void
*/
public function main()
{
try {
// get correct DbmsSyntax object
$dbms = substr($this->url, 0, strpos($this->url, ':'));
$dbmsSyntaxFactory = new DbmsSyntaxFactory($dbms);
$this->dbmsSyntax = $dbmsSyntaxFactory->getDbmsSyntax();
// figure out which revisions are in the db already
$this->appliedChangeNumbers = $this->getAppliedChangeNumbers();
$this->log('Current db revision: ' . $this->getLastChangeAppliedInDb());
$this->log('Checkall: ' . ($this->checkall ? 'On' : 'Off'));
$this->deploy();
} catch (Exception $e) {
throw new BuildException($e);
}
}
/**
* Get the numbers of all the patches that are already applied according to
* the changelog table in the database
*
* @return array
*/
protected function getAppliedChangeNumbers()
{
if (count($this->appliedChangeNumbers) == 0) {
$this->log('Getting applied changed numbers from DB: ' . $this->url);
$appliedChangeNumbers = array();
$dbh = new PDO($this->url, $this->userid, $this->password);
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$this->dbmsSyntax->applyAttributes($dbh);
$sql = "SELECT *
FROM " . DbDeployTask::$TABLE_NAME . "
WHERE delta_set = '$this->deltaSet'
ORDER BY change_number";
foreach ($dbh->query($sql) as $change) {
$appliedChangeNumbers[] = $change['change_number'];
}
$this->appliedChangeNumbers = $appliedChangeNumbers;
}
return $this->appliedChangeNumbers;
}
/**
* Get the number of the last patch applied to the database
*
* @return int|mixed The highest patch number that is applied in the db
*/
protected function getLastChangeAppliedInDb()
{
return (count($this->appliedChangeNumbers) > 0)
? max($this->appliedChangeNumbers) : 0;
}
/**
* Create the deploy and undo deploy outputfiles
*
* @return void
*/
protected function deploy()
{
// create deploy outputfile
$this->createOutputFile($this->outputFile, false);
// create undo deploy outputfile
$this->createOutputFile($this->undoOutputFile, true);
}
/**
* Generate the sql for doing/undoing the deployment and write it to a file
*
* @param string $file
* @param bool $undo
* @return void
*/
protected function createOutputFile($file, $undo = false)
{
$fileHandle = fopen($file, "w+");
$sql = $this->generateSql($undo);
fwrite($fileHandle, $sql);
}
/**
* Generate the sql for doing/undoing this deployment
*
* @param bool $undo
* @return string The sql
*/
protected function generateSql($undo = false)
{
$sql = '';
$lastChangeAppliedInDb = $this->getLastChangeAppliedInDb();
$files = $this->getDeltasFilesArray();
$this->sortFiles($files, $undo);
foreach ($files as $fileChangeNumber => $fileName) {
if ($this->fileNeedsToBeRead($fileChangeNumber, $lastChangeAppliedInDb)) {
$sql .= '-- Fragment begins: ' . $fileChangeNumber . ' --' . "\n";
if (!$undo) {
$sql .= 'INSERT INTO ' . DbDeployTask::$TABLE_NAME . '
(change_number, delta_set, start_dt, applied_by, description)' .
' VALUES (' . $fileChangeNumber . ', \'' . $this->deltaSet . '\', ' .
$this->dbmsSyntax->generateTimestamp() .
', \'' . $this->appliedBy . '\', \'' . $fileName . '\');' . "\n";
}
// read the file
$fullFileName = $this->dir . '/' . $fileName;
$fh = fopen($fullFileName, 'r');
$contents = fread($fh, filesize($fullFileName));
// allow construct with and without space added
$split = strpos($contents, '-- //@UNDO');
if ($split === false) {
$split = strpos($contents, '--//@UNDO');
}
if ($split === false) {
$split = strlen($contents);
}
if ($undo) {
$sql .= substr($contents, $split + 10) . "\n";
$sql .= 'DELETE FROM ' . DbDeployTask::$TABLE_NAME . '
WHERE change_number = ' . $fileChangeNumber . '
AND delta_set = \'' . $this->deltaSet . '\';' . "\n";
} else {
$sql .= substr($contents, 0, $split);
// Ensuring there's a newline after the final -- //
$sql .= PHP_EOL;
$sql .= 'UPDATE ' . DbDeployTask::$TABLE_NAME . '
SET complete_dt = ' . $this->dbmsSyntax->generateTimestamp() . '
WHERE change_number = ' . $fileChangeNumber . '
AND delta_set = \'' . $this->deltaSet . '\';' . "\n";
}
$sql .= '-- Fragment ends: ' . $fileChangeNumber . ' --' . "\n";
}
}
return $sql;
}
/**
* Get a list of all the patch files in the patch file directory
*
* @return array
*/
protected function getDeltasFilesArray()
{
$files = array();
$baseDir = realpath($this->dir);
$dh = opendir($baseDir);
if ($dh === false) {
return $files;
}
$fileChangeNumberPrefix = '';
while (($file = readdir($dh)) !== false) {
if (preg_match('[\d+]', $file, $fileChangeNumberPrefix)) {
$files[intval($fileChangeNumberPrefix[0])] = $file;
}
}
return $files;
}
/**
* Sort files in the patch files directory (ascending or descending depending on $undo boolean)
*
* @param array $files
* @param bool $undo
* @return void
*/
protected function sortFiles(&$files, $undo)
{
if ($undo) {
krsort($files);
} else {
ksort($files);
}
}
/**
* Determine if this patch file need to be deployed
* (using fileChangeNumber, lastChangeAppliedInDb and $this->checkall)
*
* @param int $fileChangeNumber
* @param string $lastChangeAppliedInDb
* @return bool True or false if patch file needs to be deployed
*/
protected function fileNeedsToBeRead($fileChangeNumber, $lastChangeAppliedInDb)
{
if ($this->checkall) {
return (!in_array($fileChangeNumber, $this->appliedChangeNumbers));
} else {
return ($fileChangeNumber > $lastChangeAppliedInDb && $fileChangeNumber <= $this->lastChangeToApply);
}
}
/**
* Set the url for the database connection
*
* @param string $url
* @return void
*/
public function setUrl($url)
{
$this->url = $url;
}
/**
* Set the userid for the database connection
*
* @param string $userid
* @return void
*/
public function setUserId($userid)
{
$this->userid = $userid;
}
/**
* Set the password for the database connection
*
* @param string $password
* @return void
*/
public function setPassword($password)
{
$this->password = $password;
}
/**
* Set the directory where to find the patchfiles
*
* @param string $dir
* @return void
*/
public function setDir($dir)
{
$this->dir = $dir;
}
/**
* Set the outputfile which contains all patch sql statements for this deployment
*
* @param string $outputFile
* @return void
*/
public function setOutputFile($outputFile)
{
$this->outputFile = $outputFile;
}
/**
* Set the undo outputfile which contains all undo statements for this deployment
*
* @param string $undoOutputFile
* @return void
*/
public function setUndoOutputFile($undoOutputFile)
{
$this->undoOutputFile = $undoOutputFile;
}
/**
* Set the lastchangetoapply property
*
* @param int $lastChangeToApply
* @return void
*/
public function setLastChangeToApply($lastChangeToApply)
{
$this->lastChangeToApply = $lastChangeToApply;
}
/**
* Set the deltaset property
*
* @param string $deltaSet
* @return void
*/
public function setDeltaSet($deltaSet)
{
$this->deltaSet = $deltaSet;
}
/**
* Set the checkall property
*
* @param bool $checkall
* @return void
*/
public function setCheckAll($checkall)
{
$this->checkall = (int) $checkall;
}
/**
* Set the appliedBy property
*
* @param string $appliedBy
* @return void
*/
public function setAppliedBy($appliedBy)
{
$this->appliedBy = $appliedBy;
}
/**
* Nested adder, adds a set of files (nested fileset attribute).
*
* @param FileSet $fs
* @return void
*/
public function addFileSet(FileSet $fs)
{
$this->filesets[] = $fs;
}
}
phing-2.14.0/tasks/ext/dbdeploy/DbmsSyntaxSQLite.php 0000775 0001750 0001750 00000002652 12670364674 022160 0 ustar michiel michiel .
*/
/**
* Utility class for generating necessary server-specific SQL commands
*
* @author Luke Crouch at SourceForge (http://sourceforge.net)
* @version $Id: f154ae7623dcdc04e60284fe70bea1da99ab1254 $
* @package phing.tasks.ext.dbdeploy
*/
class DbmsSyntaxSQLite extends DbmsSyntax
{
/**
* @return string
*/
public function generateTimestamp()
{
return "strftime('%s','now')";
}
}
phing-2.14.0/tasks/ext/dbdeploy/DbmsSyntaxFactory.php 0000775 0001750 0001750 00000004744 12670364674 022432 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/dbdeploy/DbmsSyntax.php';
/**
* Factory for generating dbms-specific syntax-generating objects
*
* @author Luke Crouch at SourceForge (http://sourceforge.net)
* @version $Id: 1d817a30c44e1f87a0f51ecebdc9fefe3177790c $
* @package phing.tasks.ext.dbdeploy
*/
class DbmsSyntaxFactory
{
private $dbms;
/**
* @param $dbms
*/
public function __construct($dbms)
{
$this->dbms = $dbms;
}
public function getDbmsSyntax()
{
switch ($this->dbms) {
case('sqlite') :
require_once 'phing/tasks/ext/dbdeploy/DbmsSyntaxSQLite.php';
return new DbmsSyntaxSQLite();
case('mysql'):
require_once 'phing/tasks/ext/dbdeploy/DbmsSyntaxMysql.php';
return new DbmsSyntaxMysql();
case 'odbc':
case('mssql'):
case 'dblib':
require_once 'phing/tasks/ext/dbdeploy/DbmsSyntaxMsSql.php';
return new DbmsSyntaxMsSql();
case('pgsql'):
require_once 'phing/tasks/ext/dbdeploy/DbmsSyntaxPgSQL.php';
return new DbmsSyntaxPgSQL();
case 'oci':
require_once 'phing/tasks/ext/dbdeploy/DbmsSyntaxOracle.php';
return new DbmsSyntaxOracle();
default:
throw new Exception($this->dbms . ' is not supported by dbdeploy task.');
}
}
}
phing-2.14.0/tasks/ext/dbdeploy/DbmsSyntaxMsSql.php 0000775 0001750 0001750 00000002667 12670364674 022064 0 ustar michiel michiel .
*/
/**
* Utility class for generating necessary server-specific SQL commands
*
* @author Luke Crouch at SourceForge (http://sourceforge.net)
* @version $Id: ff91eb484802be6835d70ee11c6c9d7fed1e09df $
* @package phing.tasks.ext.dbdeploy
*/
class DbmsSyntaxMsSql extends DbmsSyntax
{
/**
* @return string
*/
public function generateTimestamp()
{
return "DATEDIFF(s, '19700101', GETDATE())";
}
}
phing-2.14.0/tasks/ext/dbdeploy/DbmsSyntaxMysql.php 0000775 0001750 0001750 00000002632 12670364674 022122 0 ustar michiel michiel .
*/
/**
* Utility class for generating necessary server-specific SQL commands
*
* @author Luke Crouch at SourceForge (http://sourceforge.net)
* @version $Id: 2df6bddd9e2070c0cbc8d8eab2ee0a3caafb9b20 $
* @package phing.tasks.ext.dbdeploy
*/
class DbmsSyntaxMysql extends DbmsSyntax
{
/**
* @return string
*/
public function generateTimestamp()
{
return "NOW()";
}
}
phing-2.14.0/tasks/ext/dbdeploy/DbmsSyntaxPgSQL.php 0000775 0001750 0001750 00000002563 12670364674 021746 0 ustar michiel michiel .
*/
/**
* Utility class for generating necessary server-specific SQL commands
*
* @author Remy BREUILS
* @version $Id: ee3d162c42e59a87e2cde17d64360fa16955fa85 $
* @package phing.tasks.ext.dbdeploy
*/
class DbmsSyntaxPgSQL extends DbmsSyntax
{
/**
* @return string
*/
public function generateTimestamp()
{
return "NOW()";
}
}
phing-2.14.0/tasks/ext/PhpCodeSnifferTask.php 0000664 0001750 0001750 00000056545 12670364674 020671 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* A PHP code sniffer task. Checking the style of one or more PHP source files.
*
* @author Dirk Thomas
* @version $Id: e635b2512b71e17b616bda5e66b412984c0718b0 $
* @package phing.tasks.ext
*/
class PhpCodeSnifferTask extends Task
{
/**
* A php source code filename or directory
*
* @var PhingFile
*/
protected $file; // the source file (from xml attribute)
/**
* All fileset objects assigned to this task
*
* @var FileSet[]
*/
protected $filesets = array(); // all fileset objects assigned to this task
// parameters for php code sniffer
protected $standards = array('Generic');
protected $sniffs = array();
protected $showWarnings = true;
protected $showSources = false;
protected $reportWidth = 80;
protected $verbosity = 0;
protected $tabWidth = 0;
protected $allowedFileExtensions = array('php', 'inc', 'js', 'css');
protected $allowedTypes = array();
protected $ignorePatterns = false;
protected $noSubdirectories = false;
protected $configData = array();
protected $encoding = 'iso-8859-1';
// parameters to customize output
protected $showSniffs = false;
protected $format = 'full';
protected $formatters = array();
/**
* Holds the type of the doc generator
*
* @var string
*/
protected $docGenerator = '';
/**
* Holds the outfile for the documentation
*
* @var PhingFile
*/
protected $docFile = null;
private $haltonerror = false;
private $haltonwarning = false;
private $skipversioncheck = false;
private $propertyName = null;
/**
* Cache data storage
* @var DataStore
*/
protected $cache;
/**
* Load the necessary environment for running PHP_CodeSniffer.
*
* @return void
*/
public function init()
{
}
/**
* File to be performed syntax check on
* @param PhingFile $file
*/
public function setFile(PhingFile $file)
{
$this->file = $file;
}
/**
* Nested adder, adds a set of files (nested fileset attribute).
*
* @param FileSet $fs
* @return void
*/
public function addFileSet(FileSet $fs)
{
$this->filesets[] = $fs;
}
/**
* Sets the coding standard to test for
*
* @param string $standards The coding standards
*
* @return void
*/
public function setStandard($standards)
{
$this->standards = array();
$token = ' ,;';
$ext = strtok($standards, $token);
while ($ext !== false) {
$this->standards[] = $ext;
$ext = strtok($token);
}
}
/**
* Sets the sniffs which the standard should be restricted to
* @param string $sniffs
*/
public function setSniffs($sniffs)
{
$token = ' ,;';
$sniff = strtok($sniffs, $token);
while ($sniff !== false) {
$this->sniffs[] = $sniff;
$sniff = strtok($token);
}
}
/**
* Sets the type of the doc generator
*
* @param string $generator HTML or Text
*
* @return void
*/
public function setDocGenerator($generator)
{
$this->docGenerator = $generator;
}
/**
* Sets the outfile for the documentation
*
* @param PhingFile $file The outfile for the doc
*
* @return void
*/
public function setDocFile(PhingFile $file)
{
$this->docFile = $file;
}
/**
* Sets the flag if warnings should be shown
* @param boolean $show
*/
public function setShowWarnings($show)
{
$this->showWarnings = StringHelper::booleanValue($show);
}
/**
* Sets the flag if sources should be shown
*
* @param boolean $show Whether to show sources or not
*
* @return void
*/
public function setShowSources($show)
{
$this->showSources = StringHelper::booleanValue($show);
}
/**
* Sets the width of the report
*
* @param int $width How wide the screen reports should be.
*
* @return void
*/
public function setReportWidth($width)
{
$this->reportWidth = (int) $width;
}
/**
* Sets the verbosity level
* @param int $level
*/
public function setVerbosity($level)
{
$this->verbosity = (int) $level;
}
/**
* Sets the tab width to replace tabs with spaces
* @param int $width
*/
public function setTabWidth($width)
{
$this->tabWidth = (int) $width;
}
/**
* Sets file encoding
* @param string $encoding
*/
public function setEncoding($encoding)
{
$this->encoding = $encoding;
}
/**
* Sets the allowed file extensions when using directories instead of specific files
* @param array $extensions
*/
public function setAllowedFileExtensions($extensions)
{
$this->allowedFileExtensions = array();
$token = ' ,;';
$ext = strtok($extensions, $token);
while ($ext !== false) {
$this->allowedFileExtensions[] = $ext;
$ext = strtok($token);
}
}
/**
* Sets the allowed types for the PHP_CodeSniffer::suggestType()
* @param array $types
*/
public function setAllowedTypes($types)
{
$this->allowedTypes = array();
$token = ' ,;';
$type = strtok($types, $token);
while ($type !== false) {
$this->allowedTypes[] = $type;
$type = strtok($token);
}
}
/**
* Sets the ignore patterns to skip files when using directories instead of specific files
* @param $patterns
* @internal param array $extensions
*/
public function setIgnorePatterns($patterns)
{
$this->ignorePatterns = array();
$token = ' ,;';
$pattern = strtok($patterns, $token);
while ($pattern !== false) {
$this->ignorePatterns[$pattern] = 'relative';
$pattern = strtok($token);
}
}
/**
* Sets the flag if subdirectories should be skipped
* @param boolean $subdirectories
*/
public function setNoSubdirectories($subdirectories)
{
$this->noSubdirectories = StringHelper::booleanValue($subdirectories);
}
/**
* Creates a config parameter for this task
*
* @return Parameter The created parameter
*/
public function createConfig()
{
$num = array_push($this->configData, new Parameter());
return $this->configData[$num - 1];
}
/**
* Sets the flag if the used sniffs should be listed
* @param boolean $show
*/
public function setShowSniffs($show)
{
$this->showSniffs = StringHelper::booleanValue($show);
}
/**
* Sets the output format
* @param string $format
*/
public function setFormat($format)
{
$this->format = $format;
}
/**
* Create object for nested formatter element.
* @return CodeSniffer_FormatterElement
*/
public function createFormatter()
{
$num = array_push(
$this->formatters,
new PhpCodeSnifferTask_FormatterElement()
);
return $this->formatters[$num - 1];
}
/**
* Sets the haltonerror flag
* @param boolean $value
*/
public function setHaltonerror($value)
{
$this->haltonerror = $value;
}
/**
* Sets the haltonwarning flag
* @param boolean $value
*/
public function setHaltonwarning($value)
{
$this->haltonwarning = $value;
}
/**
* Sets the skipversioncheck flag
* @param boolean $value
*/
public function setSkipVersionCheck($value)
{
$this->skipversioncheck = $value;
}
/**
* Sets the name of the property to use
* @param $propertyName
*/
public function setPropertyName($propertyName)
{
$this->propertyName = $propertyName;
}
/**
* Returns the name of the property to use
*/
public function getPropertyName()
{
return $this->propertyName;
}
/**
* Whether to store last-modified times in cache
*
* @param PhingFile $file
*/
public function setCacheFile(PhingFile $file)
{
$this->cache = new DataStore($file);
}
/**
* Return the list of files to parse
*
* @return string[] list of absolute files to parse
*/
protected function getFilesToParse()
{
$filesToParse = array();
if ($this->file instanceof PhingFile) {
$filesToParse[] = $this->file->getPath();
} else {
// append any files in filesets
foreach ($this->filesets as $fs) {
$dir = $fs->getDir($this->project)->getAbsolutePath();
foreach ($fs->getDirectoryScanner($this->project)->getIncludedFiles() as $filename) {
$fileAbsolutePath = $dir . DIRECTORY_SEPARATOR . $filename;
if ($this->cache) {
$lastMTime = $this->cache->get($fileAbsolutePath);
$currentMTime = filemtime($fileAbsolutePath);
if ($lastMTime >= $currentMTime) {
continue;
} else {
$this->cache->put($fileAbsolutePath, $currentMTime);
}
}
$filesToParse[] = $fileAbsolutePath;
}
}
}
return $filesToParse;
}
/**
* Executes PHP code sniffer against PhingFile or a FileSet
*/
public function main()
{
if (!class_exists('PHP_CodeSniffer')) {
@include_once 'PHP/CodeSniffer.php';
if (!class_exists('PHP_CodeSniffer')) {
throw new BuildException("This task requires the PHP_CodeSniffer package installed and available on the include path", $this->getLocation(
));
}
}
/**
* Determine PHP_CodeSniffer version number
*/
if (!$this->skipversioncheck) {
if (defined('PHP_CodeSniffer::VERSION')) {
preg_match('/\d\.\d\.\d/', PHP_CodeSniffer::VERSION, $version);
} else {
preg_match('/\d\.\d\.\d/', shell_exec('phpcs --version'), $version);
}
if (version_compare($version[0], '1.2.2') < 0) {
throw new BuildException(
'PhpCodeSnifferTask requires PHP_CodeSniffer version >= 1.2.2',
$this->getLocation()
);
}
}
if (!isset($this->file) and count($this->filesets) == 0) {
throw new BuildException("Missing either a nested fileset or attribute 'file' set");
}
if (count($this->formatters) == 0) {
// turn legacy format attribute into formatter
$fmt = new PhpCodeSnifferTask_FormatterElement();
$fmt->setType($this->format);
$fmt->setUseFile(false);
$this->formatters[] = $fmt;
}
$fileList = $this->getFilesToParse();
$cwd = getcwd();
// Save command line arguments because it confuses PHPCS (version 1.3.0)
$oldArgs = $_SERVER['argv'];
$_SERVER['argv'] = array();
$_SERVER['argc'] = 0;
include_once 'phing/tasks/ext/phpcs/PhpCodeSnifferTask_Wrapper.php';
$codeSniffer = new PhpCodeSnifferTask_Wrapper($this->verbosity, $this->tabWidth, $this->encoding);
$codeSniffer->setAllowedFileExtensions($this->allowedFileExtensions);
if ($this->allowedTypes) {
PhpCodeSnifferTask_Wrapper::$allowedTypes = $this->allowedTypes;
}
if (is_array($this->ignorePatterns)) {
$codeSniffer->setIgnorePatterns($this->ignorePatterns);
}
foreach ($this->configData as $configData) {
$codeSniffer->setConfigData($configData->getName(), $configData->getValue(), true);
}
/*
* Verifying if standard is installed only after setting config data.
* Custom standard paths could be provided via installed_paths config parameter.
*/
foreach($this->standards as $standard) {
if (PHP_CodeSniffer::isInstalledStandard($standard) === false) {
// They didn't select a valid coding standard, so help them
// out by letting them know which standards are installed.
$installedStandards = PHP_CodeSniffer::getInstalledStandards();
$numStandards = count($installedStandards);
$errMsg = '';
if ($numStandards === 0) {
$errMsg = 'No coding standards are installed.';
} else {
$lastStandard = array_pop($installedStandards);
if ($numStandards === 1) {
$errMsg = 'The only coding standard installed is ' . $lastStandard;
} else {
$standardList = implode(', ', $installedStandards);
$standardList .= ' and ' . $lastStandard;
$errMsg = 'The installed coding standards are ' . $standardList;
}
}
throw new BuildException(
'ERROR: the "' . $standard . '" coding standard is not installed. ' . $errMsg,
$this->getLocation()
);
}
}
if (!$this->showWarnings) {
$codeSniffer->cli->warningSeverity = 0;
}
// nasty integration hack
$values = $codeSniffer->cli->getDefaults();
$_SERVER['argv'] = array('t');
$_SERVER['argc'] = 1;
foreach ($this->formatters as $fe) {
$output = ($fe->getUseFile() ? $fe->getOutFile() : null);
$_SERVER['argv'][] = '--report-' . $fe->getType() . '=' . $output;
$_SERVER['argc']++;
}
if ($this->cache) {
require_once 'phing/tasks/ext/phpcs/Reports_PhingRemoveFromCache.php';
PHP_CodeSniffer_Reports_PhingRemoveFromCache::setCache($this->cache);
// add a fake report to remove from cache
$_SERVER['argv'][] = '--report-phingRemoveFromCache=';
$_SERVER['argc']++;
}
$codeSniffer->process($fileList, $this->standards, $this->sniffs, $this->noSubdirectories);
$_SERVER['argv'] = array();
$_SERVER['argc'] = 0;
if ($this->cache) {
PHP_CodeSniffer_Reports_PhingRemoveFromCache::setCache(null);
$this->cache->commit();
}
$this->printErrorReport($codeSniffer);
// generate the documentation
if ($this->docGenerator !== '' && $this->docFile !== null) {
ob_start();
$codeSniffer->generateDocs($this->standards, $this->sniffs, $this->docGenerator);
$output = ob_get_contents();
ob_end_clean();
// write to file
$outputFile = $this->docFile->getPath();
$check = file_put_contents($outputFile, $output);
if (is_bool($check) && !$check) {
throw new BuildException('Error writing doc to ' . $outputFile);
}
} elseif ($this->docGenerator !== '' && $this->docFile === null) {
$codeSniffer->generateDocs($this->standards, $this->sniffs, $this->docGenerator);
}
if ($this->haltonerror && $codeSniffer->reporting->totalErrors > 0) {
throw new BuildException('phpcodesniffer detected ' . $codeSniffer->reporting->totalErrors . ' error' . ($codeSniffer->reporting->totalErrors > 1 ? 's' : ''));
}
if ($this->haltonwarning && $codeSniffer->reporting->totalWarnings > 0) {
throw new BuildException('phpcodesniffer detected ' . $codeSniffer->reporting->totalWarnings . ' warning' . ($codeSniffer->reporting->totalWarnings > 1 ? 's' : ''));
}
$_SERVER['argv'] = $oldArgs;
$_SERVER['argc'] = count($oldArgs);
chdir($cwd);
}
/**
* Prints the error report.
*
* @param PHP_CodeSniffer $phpcs The PHP_CodeSniffer object containing
* the errors.
*/
protected function printErrorReport($phpcs)
{
$sniffs = $phpcs->getSniffs();
$sniffStr = '';
foreach ($sniffs as $sniff) {
if (is_string($sniff)) {
$sniffStr .= '- ' . $sniff . PHP_EOL;
} else {
$sniffStr .= '- ' . get_class($sniff) . PHP_EOL;
}
}
$this->project->setProperty($this->getPropertyName(), (string) $sniffStr);
if ($this->showSniffs) {
$this->log('The list of used sniffs (#' . count($sniffs) . '): ' . PHP_EOL . $sniffStr, Project::MSG_INFO);
}
// process output
$reporting = $phpcs->reporting;
foreach ($this->formatters as $fe) {
$reportFile = null;
if ($fe->getUseFile()) {
$reportFile = $fe->getOutfile();
//ob_start();
}
// Crude check, but they broke backwards compatibility
// with a minor version release.
if (PHP_CodeSniffer::VERSION >= '2.2.0') {
$cliValues = array('colors' => false);
$reporting->printReport($fe->getType(),
$this->showSources,
$cliValues,
$reportFile,
$this->reportWidth);
} else {
$reporting->printReport($fe->getType(),
$this->showSources,
$reportFile,
$this->reportWidth);
}
// reporting class uses ob_end_flush(), but we don't want
// an output if we use a file
if ($fe->getUseFile()) {
//ob_end_clean();
}
}
}
/**
* Outputs the results with a custom format
*
* @param array $report Packaged list of all errors in each file
*/
protected function outputCustomFormat($report)
{
$files = $report['files'];
foreach ($files as $file => $attributes) {
$errors = $attributes['errors'];
$warnings = $attributes['warnings'];
$messages = $attributes['messages'];
if ($errors > 0) {
$this->log(
$file . ': ' . $errors . ' error' . ($errors > 1 ? 's' : '') . ' detected',
Project::MSG_ERR
);
$this->outputCustomFormatMessages($messages, 'ERROR');
} else {
$this->log($file . ': No syntax errors detected', Project::MSG_VERBOSE);
}
if ($warnings > 0) {
$this->log(
$file . ': ' . $warnings . ' warning' . ($warnings > 1 ? 's' : '') . ' detected',
Project::MSG_WARN
);
$this->outputCustomFormatMessages($messages, 'WARNING');
}
}
$totalErrors = $report['totals']['errors'];
$totalWarnings = $report['totals']['warnings'];
$this->log(count($files) . ' files were checked', Project::MSG_INFO);
if ($totalErrors > 0) {
$this->log($totalErrors . ' error' . ($totalErrors > 1 ? 's' : '') . ' detected', Project::MSG_ERR);
} else {
$this->log('No syntax errors detected', Project::MSG_INFO);
}
if ($totalWarnings > 0) {
$this->log($totalWarnings . ' warning' . ($totalWarnings > 1 ? 's' : '') . ' detected', Project::MSG_INFO);
}
}
/**
* Outputs the messages of a specific type for one file
* @param array $messages
* @param string $type
*/
protected function outputCustomFormatMessages($messages, $type)
{
foreach ($messages as $line => $messagesPerLine) {
foreach ($messagesPerLine as $column => $messagesPerColumn) {
foreach ($messagesPerColumn as $message) {
$msgType = $message['type'];
if ($type == $msgType) {
$logLevel = Project::MSG_INFO;
if ($msgType == 'ERROR') {
$logLevel = Project::MSG_ERR;
} else {
if ($msgType == 'WARNING') {
$logLevel = Project::MSG_WARN;
}
}
$text = $message['message'];
$string = $msgType . ' in line ' . $line . ' column ' . $column . ': ' . $text;
$this->log($string, $logLevel);
}
}
}
}
}
} //end phpCodeSnifferTask
/**
* @package phing.tasks.ext
*/
class PhpCodeSnifferTask_FormatterElement extends DataType
{
/**
* Type of output to generate
* @var string
*/
protected $type = "";
/**
* Output to file?
* @var bool
*/
protected $useFile = true;
/**
* Output file.
* @var string
*/
protected $outfile = "";
/**
* Validate config.
*/
public function parsingComplete()
{
if (empty($this->type)) {
throw new BuildException("Format missing required 'type' attribute.");
}
if ($this->useFile && empty($this->outfile)) {
throw new BuildException("Format requires 'outfile' attribute when 'useFile' is true.");
}
}
/**
* @param $type
*/
public function setType($type)
{
$this->type = $type;
}
/**
* @return string
*/
public function getType()
{
return $this->type;
}
/**
* @param $useFile
*/
public function setUseFile($useFile)
{
$this->useFile = $useFile;
}
/**
* @return bool
*/
public function getUseFile()
{
return $this->useFile;
}
/**
* @param $outfile
*/
public function setOutfile($outfile)
{
$this->outfile = $outfile;
}
/**
* @return string
*/
public function getOutfile()
{
return $this->outfile;
}
} //end FormatterElement
phing-2.14.0/tasks/ext/PatchTask.php 0000775 0001750 0001750 00000015453 12670364674 017065 0 ustar michiel michiel patchFile = $file;
}
/**
* The file to patch
*
* Optional if it can be inferred from the diff file.
*
* @param string $file File to patch
* @return void
*/
public function setOriginalFile($file)
{
$this->originalFile = $file;
}
/**
* The name of a file to send the output to, instead of patching
* the file(s) in place
*
* Optional.
*
* @param string $file File to send the output to
* @return void
*/
public function setDestFile($file)
{
if ($file !== null) {
$this->cmdArgs [] = "--output=$file";
}
}
/**
* Flag to create backups
*
* Optional, default - false
*
* @param bool $backups If true create backups
* @return void
*/
public function setBackups($backups)
{
if ($backups) {
$this->cmdArgs [] = '--backup';
}
}
/**
* Flag to ignore whitespace differences;
*
* Default - false
*
* @param bool $ignore If true ignore whitespace differences
* @return void
*/
public function setIgnoreWhiteSpace($ignore)
{
if ($ignore) {
$this->cmdArgs [] = '--ignore-whitespace';
}
}
/**
* Strip the smallest prefix containing num leading slashes
* from filenames.
*
* patch's --strip option.
*
* @param int $num number of lines to strip
* @return void
* @throws BuildException if num is < 0, or other errors
*/
public function setStrip($num)
{
if ($num < 0) {
throw new BuildException('strip has to be >= 0');
}
$this->strip = $num;
}
/**
* Work silently unless an error occurs
*
* Optional, default - false
* @param bool $flag If true suppress set the -s option on the patch command
* @return void
*/
public function setQuiet($flag)
{
if ($flag) {
$this->cmdArgs [] = '--silent';
}
}
/**
* Assume patch was created with old and new files swapped
*
* Optional, default - false
*
* @param bool $flag If true set the -R option on the patch command
* @return void
*/
public function setReverse($flag)
{
if ($flag) {
$this->cmdArgs [] = '--reverse';
}
}
/**
* The directory to run the patch command in
*
* Defaults to the project's base directory.
*
* @param string $directory Directory to run the patch command in
* @return void
*/
public function setDir($directory)
{
$this->cmdArgs [] = "--directory=$directory";
}
/**
* Ignore patches that seem to be reversed or already applied
*
* @param bool $flag If true set the -N (--forward) option
* @return void
*/
public function setForward($flag)
{
if ($flag) {
$this->cmdArgs [] = "--forward";
}
}
/**
* Set the maximum fuzz factor
*
* Defaults to 0
*
* @param string $value Value of a fuzz factor
* @return void
*/
public function setFuzz($value)
{
$this->cmdArgs [] = "--fuzz=$value";
}
/**
* If true, stop the build process if the patch command
* exits with an error status.
*
* The default is "false"
*
* @param bool $value "true" if it should halt, otherwise "false"
* @return void
*/
public function setHaltOnFailure($value)
{
$this->haltOnFailure = $value;
}
/**
* Main task method
*
* @return void
* @throws BuildException when it all goes a bit pear shaped
*/
public function main()
{
if ($this->patchFile == null) {
throw new BuildException('patchfile argument is required');
}
// Define patch file
$this->cmdArgs [] = '-i ' . $this->patchFile;
// Define strip factor
if ($this->strip != null) {
$this->cmdArgs [] = '--strip=' . $this->strip;
}
// Define original file if specified
if ($this->originalFile != null) {
$this->cmdArgs [] = $this->originalFile;
}
$cmd = self::CMD . implode(' ', $this->cmdArgs);
$this->log('Applying patch: ' . $this->patchFile);
exec($cmd, $output, $exitCode);
foreach ($output as $line) {
$this->log($line, Project::MSG_VERBOSE);
}
if ($exitCode != 0 && $this->haltOnFailure) {
throw new BuildException("Task exited with code $exitCode");
}
}
}
phing-2.14.0/tasks/ext/phpdoc/PhpDocumentorTask.php 0000775 0001750 0001750 00000032433 12670364674 022067 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* Task to run PhpDocumentor.
*
* @author Hans Lellelid
* @author Michiel Rook
* @version $Id: 11e97cff8a9f2331750049c1c8fe4fb57f3cc962 $
* @package phing.tasks.ext.phpdoc
*/
class PhpDocumentorTask extends Task
{
/**
* @var string Title for browser window / package index.
*/
protected $title;
/**
* @var PhingFile The target directory for output files.
*/
protected $destdir;
/**
* @var array FileSet[] Filesets for files to parse.
*/
protected $filesets = array();
/**
* @var array FileSet[] Project documentation (README/INSTALL/CHANGELOG) files.
*/
protected $projDocFilesets = array();
/**
* @var string Package output format.
*/
protected $output;
/**
* @var boolean Whether to generate sourcecode for each file parsed.
*/
protected $linksource = false;
/**
* @var boolean Whether to parse private members.
*/
protected $parsePrivate = false;
/**
* @var boolean Whether to use javadoc descriptions (more primitive).
*/
protected $javadocDesc = false;
/**
* @var PhingFile Base directory for locating template files.
*/
protected $templateBase;
/**
* @var boolean Wheter to suppress output.
*/
protected $quiet = false;
/**
* @var string Comma-separated list of packages to output.
*/
protected $packages;
/**
* @var string Comma-separated list of tags to ignore.
*/
protected $ignoreTags;
/**
* @var string Default package name.
*/
protected $defaultPackageName;
/**
* @var string Default category name.
*/
protected $defaultCategoryName;
/**
* @var PhingFile Directory in which to look for examples.
*/
protected $examplesDir;
/**
* @var PhingFile Directory in which to look for configuration files.
*/
protected $configDir;
/**
* @var boolean Whether to parse as a PEAR repository.
*/
protected $pear = false;
/**
* @var boolean Control whether or not warnings will be shown for
* undocumented elements. Useful for identifying classes and
* methods that haven't yet been documented.
*/
protected $undocumentedelements = false;
/**
* @var string custom tags, will be recognized and put in tags[] instead of
* unknowntags[].
*/
protected $customtags = '';
/**
* @var string files to ignore
*/
protected $ignore = '';
/**
* Set the title for the generated documentation
* @param $title
*/
public function setTitle($title)
{
$this->title = $title;
}
/**
* Set the destination directory for the generated documentation
* @param PhingFile $destdir
*/
public function setDestdir(PhingFile $destdir)
{
$this->destdir = $destdir;
}
/**
* Alias for {@link setDestdir()}.
* @see setDestdir()
* @param PhingFile $destdir
*/
public function setTarget(PhingFile $destdir)
{
$this->setDestdir($destdir);
}
/**
* Set the output format (e.g. HTML:Smarty:PHP).
* @param string $output
*/
public function setOutput($output)
{
$this->output = $output;
}
/**
* Set whether to generate sourcecode for each file parsed
* @param boolean
*/
public function setSourcecode($b)
{
$this->setLinksource($b);
}
/**
* Set whether to generate sourcecode for each file parsed
* @param boolean
*/
public function setLinksource($b)
{
$this->linksource = $b;
}
/**
* Set whether to suppress output.
* @param boolean $b
*/
public function setQuiet($b)
{
$this->quiet = $b;
}
/**
* Should private members/classes be documented
* @param boolean
*/
public function setParseprivate($parseprivate)
{
$this->parsePrivate = $parseprivate;
}
/**
* Whether to use javadoc descriptions (more primitive).
* @param boolean
*/
public function setJavadocdesc($javadoc)
{
$this->javadocDesc = $javadoc;
}
/**
* Set (comma-separated) list of packages to output.
*
* @param string $packages
*/
public function setPackageoutput($packages)
{
$this->packages = $packages;
}
/**
* Set (comma-separated) list of tags to ignore.
*
* @param string $tags
*/
public function setIgnoretags($tags)
{
$this->ignoreTags = $tags;
}
/**
* Set a directory to search for examples in.
* @param PhingFile $d
*/
public function setExamplesdir(PhingFile $d)
{
$this->examplesDir = $d;
}
/**
* Set a directory to search for configuration files in.
* @param PhingFile $d
*/
public function setConfigdir(PhingFile $d)
{
$this->configDir = $d;
}
/**
* Sets the default package name.
* @param string $name
*/
public function setDefaultpackagename($name)
{
$this->defaultPackageName = $name;
}
/**
* Sets the default category name.
* @param string $name
*/
public function setDefaultcategoryname($name)
{
$this->defaultCategoryName = $name;
}
/**
* Set whether to parse as PEAR repository.
* @param boolean $b
*/
public function setPear($b)
{
$this->pear = $b;
}
/**
* Creates a FileSet.
* @return FileSet
*/
public function createFileset()
{
$num = array_push($this->filesets, new FileSet());
return $this->filesets[$num - 1];
}
/**
* Creates a readme/install/changelog fileset.
* @return FileSet
*/
public function createProjdocfileset()
{
$num = array_push($this->projDocFilesets, new FileSet());
return $this->projDocFilesets[$num - 1];
}
/**
* Control whether or not warnings will be shown for undocumented elements.
* Useful for identifying classes and methods that haven't yet been
* documented.
* @param boolean $b
*/
public function setUndocumentedelements($b)
{
$this->undocumentedelements = $b;
}
/**
* custom tags, will be recognized and put in tags[] instead of
* unknowntags[].
*
* @param string $sCustomtags
*/
public function setCustomtags($sCustomtags)
{
$this->customtags = $sCustomtags;
}
/**
* Set base location of all templates for this parse.
*
* @param PhingFile $oTemplateBase
* @internal param PhingFile $destdir
*/
public function setTemplateBase(PhingFile $oTemplateBase)
{
$this->templateBase = $oTemplateBase;
}
/**
* Set files to ignore
* @param string $sIgnore
*/
public function setIgnore($sIgnore)
{
$this->ignore = $sIgnore;
}
/**
* Searches include_path for PhpDocumentor install and adjusts include_path appropriately.
* @throws BuildException - if unable to find PhpDocumentor on include_path
*/
protected function findPhpDocumentorInstall()
{
$found = null;
foreach (Phing::explodeIncludePath() as $path) {
$testpath = $path . DIRECTORY_SEPARATOR . 'PhpDocumentor';
if (file_exists($testpath)) {
$found = $testpath;
break;
}
}
if (!$found) {
throw new BuildException("PhpDocumentor task depends on PhpDocumentor being installed and on include_path.", $this->getLocation(
));
}
// otherwise, adjust the include_path to path to include the PhpDocumentor directory ...
set_include_path(get_include_path() . PATH_SEPARATOR . $found);
include_once "phpDocumentor/Setup.inc.php";
if (!class_exists('phpDocumentor_setup')) {
throw new BuildException("Error including PhpDocumentor setup class file.");
}
}
/**
* Main entrypoint of the task
* Loads the necessary environment for running PhpDoc, then runs PhpDoc
*
* @throws BuildException - if the phpdoc classes can't be loaded.
*/
public function main()
{
$this->findPhpDocumentorInstall();
include_once 'phing/tasks/ext/phpdoc/PhingPhpDocumentorSetup.php';
$this->validate();
$configdir = $this->configDir ? $this->configDir->getAbsolutePath() : null;
$phpdoc = new PhingPhpDocumentorSetup($configdir, $this);
$this->setPhpDocumentorOptions($phpdoc);
//$phpdoc->readCommandLineSettings();
$phpdoc->setupConverters($this->output);
$phpdoc->createDocs();
}
/**
* Validates that necessary minimum options have been set.
* @throws BuildException if validation doesn't pass
*/
protected function validate()
{
if (!$this->destdir) {
throw new BuildException("You must specify a destdir for phpdoc.", $this->getLocation());
}
if (!$this->output) {
throw new BuildException("You must specify an output format for phpdoc (e.g. HTML:frames:default).", $this->getLocation(
));
}
if (empty($this->filesets)) {
throw new BuildException("You have not specified any files to include () for phpdoc.", $this->getLocation(
));
}
}
/**
* Sets the options on the passed-in phpdoc setup object.
* @param PhingPhpDocumentorSetup $phpdoc
*/
protected function setPhpDocumentorOptions(PhingPhpDocumentorSetup $phpdoc)
{
// Title MUST be set first ... (because it re-initializes the internal state of the PhpDocu renderer)
if ($this->title) {
$phpdoc->setTitle($this->title);
}
if ($this->parsePrivate) {
$phpdoc->setParsePrivate();
}
if ($this->javadocDesc) {
$phpdoc->setJavadocDesc();
}
if ($this->quiet) {
$phpdoc->setQuietMode();
}
if ($this->destdir) {
$phpdoc->setTargetDir($this->destdir->getAbsolutePath());
}
if ($this->packages) {
$phpdoc->setPackageOutput($this->packages);
}
if ($this->templateBase) {
$phpdoc->setTemplateBase($this->templateBase->getAbsolutePath());
}
if ($this->linksource) {
$phpdoc->setGenerateSourcecode($this->linksource);
}
if ($this->examplesDir) {
$phpdoc->setExamplesDir($this->examplesDir->getAbsolutePath());
}
if ($this->ignoreTags) {
$phpdoc->setIgnoreTags($this->ignoreTags);
}
if ($this->defaultPackageName) {
$phpdoc->setDefaultPackageName($this->defaultPackageName);
}
if ($this->defaultCategoryName) {
$phpdoc->setDefaultCategoryName($this->defaultCategoryName);
}
if ($this->pear) {
$phpdoc->setPear($this->pear);
}
if ($this->ignore) {
$phpdoc->setIgnore($this->ignore);
}
// append any files in filesets
$filesToParse = array();
foreach ($this->filesets as $fs) {
$files = $fs->getDirectoryScanner($this->project)->getIncludedFiles();
foreach ($files as $filename) {
$f = new PhingFile($fs->getDir($this->project), $filename);
$filesToParse[] = $f->getAbsolutePath();
}
}
//print_r(implode(",", $filesToParse));
$phpdoc->setFilesToParse(implode(",", $filesToParse));
// append any files in filesets
$ricFiles = array();
foreach ($this->projDocFilesets as $fs) {
$files = $fs->getDirectoryScanner($this->project)->getIncludedFiles();
foreach ($files as $filename) {
$f = new PhingFile($fs->getDir($this->project), $filename);
$ricFiles[] = $f->getName();
}
}
$phpdoc->setRicFiles($ricFiles);
if ($this->undocumentedelements) {
$phpdoc->setUndocumentedelements($this->undocumentedelements);
}
if ($this->customtags) {
$phpdoc->setCustomtags($this->customtags);
}
}
}
phing-2.14.0/tasks/ext/phpdoc/PhpDocumentorExternalTask.php 0000775 0001750 0001750 00000016711 12670364674 023573 0 ustar michiel michiel .
*/
require_once 'phing/tasks/ext/phpdoc/PhpDocumentorTask.php';
/**
* Task to run phpDocumentor with an external process
*
* This classes uses the commandline phpdoc script to build documentation.
* Use this task instead of the PhpDocumentorTask when you've a clash with the
* Smarty libraries.
*
* @author Michiel Rook
* @author Markus Fischer
* @version $Id: b72762694ae5d5619ecebf9b66c08bd6ff868821 $
* @package phing.tasks.ext.phpdoc
*/
class PhpDocumentorExternalTask extends PhpDocumentorTask
{
/**
* The path to the executable for phpDocumentor
*/
protected $programPath = 'phpdoc';
protected $sourcepath = null;
/**
* @var bool ignore symlinks to other files or directories
*/
protected $ignoresymlinks = false;
/**
* Sets the path to the phpDocumentor executable
* @param $programPath
*/
public function setProgramPath($programPath)
{
$this->programPath = $programPath;
}
/**
* Returns the path to the phpDocumentor executable
*/
public function getProgramPath()
{
return $this->programPath;
}
/**
* Set the source path. A directory or a comma separate list of directories.
* @param $sourcepath
*/
public function setSourcepath($sourcepath)
{
$this->sourcepath = $sourcepath;
}
/**
* Ignore symlinks to other files or directories.
*
* @param bool $bSet
*/
public function setIgnoresymlinks($bSet)
{
$this->ignoresymlinks = $bSet;
}
/**
* Main entrypoint of the task
*/
public function main()
{
$this->validate();
$arguments = join(' ', $this->constructArguments());
$this->log("Running phpDocumentor...");
exec($this->programPath . " " . $arguments, $output, $return);
if ($return != 0) {
throw new BuildException("Could not execute phpDocumentor: " . implode(' ', $output));
}
foreach ($output as $line) {
if (strpos($line, 'ERROR') !== false) {
$this->log($line, Project::MSG_ERR);
continue;
}
$this->log($line, Project::MSG_VERBOSE);
}
}
/**
* Constructs an argument string for phpDocumentor
* @return array
*/
protected function constructArguments()
{
$aArgs = array();
if ($this->title) {
$aArgs[] = '--title "' . $this->title . '"';
}
if ($this->destdir) {
$aArgs[] = '--target "' . $this->destdir->getAbsolutePath() . '"';
}
if ($this->sourcepath) {
$aArgs[] = '--directory "' . $this->sourcepath . '"';
}
if ($this->output) {
$aArgs[] = '--output ' . $this->output;
}
if ($this->linksource) {
$aArgs[] = '--sourcecode on';
}
if ($this->parseprivate) {
$aArgs[] = '--parseprivate on';
}
if ($this->ignore) {
$aArgs[] = '--ignore ' . $this->ignore;
}
// append any files in filesets
$filesToParse = array();
foreach ($this->filesets as $fs) {
$files = $fs->getDirectoryScanner($this->project)->getIncludedFiles();
foreach ($files as $filename) {
$f = new PhingFile($fs->getDir($this->project), $filename);
$filesToParse[] = $f->getAbsolutePath();
}
}
if (count($filesToParse) > 0) {
$aArgs[] = '--filename "' . join(',', $filesToParse) . '"';
}
// append any files in filesets
$ricFiles = array();
foreach ($this->projDocFilesets as $fs) {
$files = $fs->getDirectoryScanner($this->project)->getIncludedFiles();
foreach ($files as $filename) {
$f = new PhingFile($fs->getDir($this->project), $filename);
$ricFiles[] = $f->getAbsolutePath();
}
}
if (count($ricFiles) > 0) {
$aArgs[] = '--readmeinstallchangelog "' .
join(',', $ricFiles) . '"';
}
if ($this->javadocDesc) {
$aArgs[] = '--javadocdesc on';
}
if ($this->quiet) {
$aArgs[] = '--quiet on';
}
if ($this->packages) {
$aArgs[] = '--packageoutput "' . $this->packages . '"';
}
if ($this->ignoreTags) {
$aArgs[] = '--ignore-tags "' . $this->ignoreTags . '"';
}
if ($this->defaultCategoryName) {
$aArgs[] = '--defaultcategoryname "' . $this->defaultCategoryName .
'"';
}
if ($this->examplesDir) {
$aArgs[] = '--examplesdir "' . $this->examplesDir->getAbsolutePath()
. '"';
}
if ($this->templateBase) {
$aArgs[] = '--templatebase "' . $this->templateBase->getAbsolutePath()
. '"';
}
if ($this->pear) {
$aArgs[] = '--pear on';
}
if ($this->undocumentedelements) {
$aArgs[] = '--undocumentedelements on';
}
if ($this->customtags) {
$aArgs[] = '--customtags "' . $this->customtags . '"';
}
if ($this->ignoresymlinks) {
$aArgs[] = '--ignoresymlinks on';
}
return $aArgs;
}
/**
* Override PhpDocumentorTask::init() because they're specific to the phpdoc
* API which we don't use.
*/
public function init()
{
}
/**
* Validates that necessary minimum options have been set. Based on
* PhpDocumentorTask::validate().
*/
protected function validate()
{
if (!$this->destdir) {
throw new BuildException("You must specify a destdir for phpdoc.",
$this->getLocation());
}
if (!$this->output) {
throw new BuildException("You must specify an output format for " .
"phpdoc (e.g. HTML:frames:default).", $this->getLocation());
}
if (empty($this->filesets) && !$this->sourcepath) {
throw new BuildException("You have not specified any files to " .
"include ( or sourcepath attribute) for phpdoc.",
$this->getLocation());
}
if ($this->configdir) {
$this->log(
'Ignoring unsupported configdir-Attribute',
Project::MSG_VERBOSE
);
}
}
}
;
phing-2.14.0/tasks/ext/phpdoc/PhingPhpDocumentorSetup.php 0000664 0001750 0001750 00000021371 12670364674 023247 0 ustar michiel michiel .
*/
require_once 'PhpDocumentor/phpDocumentor/Setup.inc.php';
/**
* Phing subclass of the phpDocumentor_setup class provided with PhpDocumentor to work around limitations in PhpDocumentor API.
*
* This class is necessary because phpDocumentor_setup does not expose a complete API for setting configuration options. Because
* this class must directly modify some "private" GLOBAL(!) configuration variables, it is liable to break if the PhpDocumentor
* internal implementation changes. Obviously this is far from ideal, but there's also no solution given the inflexibility of the
* PhpDocumentor design.
*
* @author Hans Lellelid @author hans
* @version $Id: 3c0527274eb0d0c2c6ed888ff23fe5b38367bb04 $
* @package phing.tasks.ext.phpdoc
*/
class PhingPhpDocumentorSetup extends phpDocumentor_setup
{
/**
* Constructs a new PhingPhpDocumentorSetup.
*
* @param null $configdir
* @param object $task The task we're working with, so we can pass it on to the ErrorTracker
* @internal param string $configDir Directory in which to look for configuration files.
*/
public function __construct($configdir = null, $task)
{
global $_phpDocumentor_cvsphpfile_exts, $_phpDocumentor_setting, $_phpDocumentor_phpfile_exts;
$this->setup = new Io();
$this->render = new phpDocumentor_IntermediateParser("Default Title");
$GLOBALS['_phpDocumentor_install_dir'] = $configdir;
$this->parseIni();
// These redundant-looking lines seem to actually make a difference.
// See: http://phing.info/trac/ticket/150
$_phpDocumentor_phpfile_exts = $GLOBALS['_phpDocumentor_phpfile_exts'];
$_phpDocumentor_cvsphpfile_exts = $GLOBALS['_phpDocumentor_cvsphpfile_exts'];
if (tokenizer_ext) {
$this->parse = new phpDocumentorTParser();
} else {
$this->parse = new Parser();
}
$this->setMemoryLimit();
include_once 'phing/tasks/ext/phpdoc/PhingPhpDocumentorErrorTracker.php';
// Inject our own error tracker to PhpDocumentor
$GLOBALS['phpDocumentor_errors'] = new PhingPhpDocumentorErrorTracker();
$GLOBALS['phpDocumentor_errors']->setTask($task);
}
/**
* Set whether to generate sourcecode for each file parsed.
*
* This method exists as a hack because there is no API exposed for this in PhpDocumentor.
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
* @param bool $b
*/
public function setGenerateSourcecode($b)
{
global $_phpDocumentor_setting;
$_phpDocumentor_setting['sourcecode'] = (boolean) $b;
}
/**
* Set an array of README/INSTALL/CHANGELOG file paths.
*
* This method exists as a hack because there is no API exposed for this in PhpDocumentor.
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
* @param array $files Absolute paths to files.
*/
public function setRicFiles($files)
{
global $_phpDocumentor_RIC_files;
$_phpDocumentor_RIC_files = $files;
}
/**
* Set comma-separated list of tags to ignore.
*
* This method exists as a hack because there is no API exposed for this in PhpDocumentor.
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
* @param string $tags
*/
public function setIgnoreTags($tags)
{
global $_phpDocumentor_setting;
$ignoretags = explode(',', $tags);
$ignoretags = array_map('trim', $ignoretags);
$tags = array();
foreach ($ignoretags as $tag) {
if (!in_array(
$tag,
array('@global', '@access', '@package', '@ignore', '@name', '@param', '@return', '@staticvar', '@var')
)
) {
$tags[] = $tag;
}
}
$_phpDocumentor_setting['ignoretags'] = $tags;
}
/**
* Set whether to parse dirs as PEAR repos.
*
* This method exists as a hack because there is no API exposed for this in PhpDocumentor.
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
* @param bool $b
*/
public function setPear($b)
{
global $_phpDocumentor_setting;
$_phpDocumentor_setting['pear'] = (boolean) $b;
}
/**
* Set fullpath to directory to look in for examples.
*
* This method exists as a hack because there is no API exposed for this in PhpDocumentor.
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
* @param string $dir
*/
public function setExamplesDir($dir)
{
global $_phpDocumentor_setting;
$_phpDocumentor_setting['examplesdir'] = $dir;
}
/**
* Sets the default package name.
*
* This method exists as a hack because there is no API exposed for this in PhpDocumentor.
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
* @param string $name
*/
public function setDefaultPackageName($name)
{
$GLOBALS['phpDocumentor_DefaultPackageName'] = trim($name);
}
/**
* Sets the default category name.
*
* This method exists as a hack because there is no API exposed for this in PhpDocumentor.
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
* @param string $name
*/
public function setDefaultCategoryName($name)
{
$GLOBALS['phpDocumentor_DefaultCategoryName'] = trim($name);
}
/**
* Enables quiet mode.
*
* This method exists as a hack because the API exposed for this method in PhpDocumentor
* doesn't work correctly.
*
* Note that because we are setting a "private" GLOBAL(!!) config var with this value, this
* is subject to break if PhpDocumentor internals changes.
*
*/
public function setQuietMode()
{
global $_phpDocumentor_setting;
$_phpDocumentor_setting['quiet'] = true;
parent::setQuietMode();
}
/**
* Control whether or not warnings will be shown for undocumented elements.
* Useful for identifying classes and methods that haven't yet been
* documented.
*
* @param bool $bEnable
*/
public function setUndocumentedelements($bEnable)
{
$this->render->setUndocumentedElementWarningsMode($bEnable);
}
/**
* custom tags, will be recognized and put in tags[] instead of
* unknowntags[]
*
* This method exists as a hack because the API exposed for this method in
* PhpDocumentor doesn't work correctly.
*
* Note that because we are setting a "private" GLOBAL(!!) config var with
* this value, this is subject to break if PhpDocumentor internals changes.
*
* @param string $sCustomtags
*/
public function setCustomtags($sCustomtags)
{
global $_phpDocumentor_setting;
$_phpDocumentor_setting['customtags'] = $sCustomtags;
}
/**
* Files to ignore
*
* @param string $sIgnore
*/
public function setIgnore($sIgnore)
{
global $_phpDocumentor_setting;
$_phpDocumentor_setting['ignore'] = $sIgnore;
}
}
phing-2.14.0/tasks/ext/phpdoc/PhpDocumentor2Task.php 0000775 0001750 0001750 00000011110 12670364674 022136 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* PhpDocumentor2 Task (http://www.phpdoc.org)
* Based on the DocBlox Task
*
* @author Michiel Rook
* @version $Id: fff99666d63c88940f9b305c2822856fa00ab5ce $
* @since 2.4.10
* @package phing.tasks.ext.phpdoc
*/
class PhpDocumentor2Task extends Task
{
/**
* List of filesets
* @var FileSet[]
*/
private $filesets = array();
/**
* Destination/target directory
* @var PhingFile
*/
private $destDir = null;
/**
* name of the template to use
* @var string
*/
private $template = "responsive-twig";
/**
* Title of the project
* @var string
*/
private $title = "API Documentation";
/**
* Name of default package
* @var string
*/
private $defaultPackageName = "Default";
/**
* Path to the phpDocumentor .phar
* @var string
*/
private $pharLocation = '';
/**
* Nested adder, adds a set of files (nested fileset attribute).
*
* @param FileSet $fs
* @return void
*/
public function addFileSet(FileSet $fs)
{
$this->filesets[] = $fs;
}
/**
* Sets destination/target directory
* @param PhingFile $destDir
*/
public function setDestDir(PhingFile $destDir)
{
$this->destDir = $destDir;
}
/**
* Convenience setter (@see setDestDir)
* @param PhingFile $output
*/
public function setOutput(PhingFile $output)
{
$this->destDir = $output;
}
/**
* Sets the template to use
* @param strings $template
*/
public function setTemplate($template)
{
$this->template = (string) $template;
}
/**
* Sets the title of the project
* @param strings $title
*/
public function setTitle($title)
{
$this->title = (string) $title;
}
/**
* Sets the default package name
* @param string $defaultPackageName
*/
public function setDefaultPackageName($defaultPackageName)
{
$this->defaultPackageName = (string) $defaultPackageName;
}
/**
* @param string $pharLocation
*/
public function setPharLocation($pharLocation)
{
$this->pharLocation = $pharLocation;
}
/**
* Forces phpDocumentor to be quiet
* @deprecated
* @param boolean $quiet
*/
public function setQuiet($quiet)
{
$this->project->log(__CLASS__ . ": the 'quiet' option has been deprecated", Project::MSG_WARN);
}
/**
* Task entry point
* @see Task::main()
*/
public function main()
{
if (empty($this->destDir)) {
throw new BuildException("You must supply the 'destdir' attribute", $this->getLocation());
}
if (empty($this->filesets)) {
throw new BuildException("You have not specified any files to include ()", $this->getLocation());
}
if (version_compare(PHP_VERSION, '5.3.0') < 0) {
throw new BuildException("The phpdocumentor2 task requires PHP 5.3+");
}
require_once 'phing/tasks/ext/phpdoc/PhpDocumentor2Wrapper.php';
$wrapper = new PhpDocumentor2Wrapper();
$wrapper->setProject($this->project);
$wrapper->setFilesets($this->filesets);
$wrapper->setDestDir($this->destDir);
$wrapper->setTemplate($this->template);
$wrapper->setTitle($this->title);
$wrapper->setDefaultPackageName($this->defaultPackageName);
$wrapper->setPharLocation($this->pharLocation);
$wrapper->run();
}
}
phing-2.14.0/tasks/ext/phpdoc/PhpDocumentor2Wrapper.php 0000775 0001750 0001750 00000017511 12670364674 022667 0 ustar michiel michiel .
*/
/**
* Wrapper around PhpDocumentor2 (so we retain
* PHP 5.2 compatibility in the main task)
*
* @author Michiel Rook
* @version $Id: 9f22f2863b649ddf3820399fd5738c58900b3a24 $
* @since 2.4.10
* @package phing.tasks.ext.phpdoc
*/
class PhpDocumentor2Wrapper
{
/**
* Phing project instance
* @var Project
*/
private $project = null;
/**
* List of filesets
* @var FileSet[]
*/
private $filesets = array();
/**
* Destination/target directory
* @var PhingFile
*/
private $destDir = null;
/**
* name of the template to use
* @var string
*/
private $template = "responsive-twig";
/**
* Title of the project
* @var string
*/
private $title = "API Documentation";
/**
* Name of the default package
* @var string
*/
private $defaultPackageName = "Default";
/**
* Path to the phpDocumentor 2 source
* @var string
*/
private $phpDocumentorPath = "";
/**
* Path to the phpDocumentor .phar
* @var string
*/
private $pharLocation = '';
/**
* @var \phpDocumentor\Application
*/
private $app = null;
/**
* Sets project instance
*
* @param Project $project
*/
public function setProject($project)
{
$this->project = $project;
}
/**
* Sets filesets array
*
* @param FileSet[] $filesets
*/
public function setFilesets($filesets)
{
$this->filesets = $filesets;
}
/**
* Sets destination/target directory
* @param PhingFile $destDir
*/
public function setDestDir(PhingFile $destDir)
{
$this->destDir = $destDir;
}
/**
* Sets the template to use
* @param string $template
*/
public function setTemplate($template)
{
$this->template = (string) $template;
}
/**
* Sets the title of the project
* @param string $title
*/
public function setTitle($title)
{
$this->title = (string) $title;
}
/**
* Sets the default package name
* @param string $defaultPackageName
*/
public function setDefaultPackageName($defaultPackageName)
{
$this->defaultPackageName = (string) $defaultPackageName;
}
/**
* @param string $pharLocation
*/
public function setPharLocation($pharLocation)
{
$this->pharLocation = $pharLocation;
}
/**
* Finds and initializes the phpDocumentor installation
*/
private function initializePhpDocumentor()
{
$phpDocumentorPath = '';
if (!empty($this->pharLocation)) {
include_once 'phar://' . $this->pharLocation . '/vendor/autoload.php';
if (!class_exists('phpDocumentor\\Bootstrap')) {
throw new BuildException(
$this->pharLocation . ' does not look like a phpDocumentor 2 .phar'
);
}
} elseif (class_exists('Composer\\Autoload\\ClassLoader', false)) {
if (!class_exists('phpDocumentor\\Bootstrap')) {
throw new BuildException('You need to install phpDocumentor 2 or add your include path to your composer installation.');
}
} else {
$phpDocumentorPath = $this->findPhpDocumentorPath();
if (empty($phpDocumentorPath)) {
throw new BuildException("Please make sure phpDocumentor 2 is installed and on the include_path.");
}
set_include_path($phpDocumentorPath . PATH_SEPARATOR . get_include_path());
require_once $phpDocumentorPath . '/phpDocumentor/Bootstrap.php';
}
$this->app = \phpDocumentor\Bootstrap::createInstance()->initialize();
$this->phpDocumentorPath = $phpDocumentorPath;
}
/**
* Build a list of files (from the fileset elements)
* and call the phpDocumentor parser
*
* @return string
*/
private function parseFiles()
{
$parser = $this->app['parser'];
$builder = $this->app['descriptor.builder'];
$builder->createProjectDescriptor();
$projectDescriptor = $builder->getProjectDescriptor();
$projectDescriptor->setName($this->title);
$paths = array();
// filesets
foreach ($this->filesets as $fs) {
$ds = $fs->getDirectoryScanner($this->project);
$dir = $fs->getDir($this->project);
$srcFiles = $ds->getIncludedFiles();
foreach ($srcFiles as $file) {
$paths[] = $dir . FileSystem::getFileSystem()->getSeparator() . $file;
}
}
$this->project->log("Will parse " . count($paths) . " file(s)", Project::MSG_VERBOSE);
$files = new \phpDocumentor\Fileset\Collection();
$files->addFiles($paths);
$mapper = new \phpDocumentor\Descriptor\Cache\ProjectDescriptorMapper($this->app['descriptor.cache']);
$mapper->garbageCollect($files);
$mapper->populate($projectDescriptor);
$parser->setPath($files->getProjectRoot());
$parser->setDefaultPackageName($this->defaultPackageName);
$parser->parse($builder, $files);
$mapper->save($projectDescriptor);
return $mapper;
}
/**
* Transforms the parsed files
*/
private function transformFiles()
{
$transformer = $this->app['transformer'];
$compiler = $this->app['compiler'];
$builder = $this->app['descriptor.builder'];
$projectDescriptor = $builder->getProjectDescriptor();
$transformer->getTemplates()->load($this->template, $transformer);
$transformer->setTarget($this->destDir->getAbsolutePath());
foreach ($compiler as $pass) {
$pass->execute($projectDescriptor);
}
}
/**
* Runs phpDocumentor 2
*/
public function run()
{
$this->initializePhpDocumentor();
$cache = $this->app['descriptor.cache'];
$cache->getOptions()->setCacheDir($this->destDir->getAbsolutePath());
$this->parseFiles();
$this->project->log("Transforming...", Project::MSG_VERBOSE);
$this->transformFiles();
}
/**
* Find the correct php documentor path
*
* @return null|string
*/
private function findPhpDocumentorPath()
{
$phpDocumentorPath = null;
$directories = array('phpDocumentor', 'phpdocumentor');
foreach ($directories as $directory) {
foreach (Phing::explodeIncludePath() as $path) {
$testPhpDocumentorPath = $path . DIRECTORY_SEPARATOR . $directory . DIRECTORY_SEPARATOR . 'src';
if (file_exists($testPhpDocumentorPath)) {
$phpDocumentorPath = $testPhpDocumentorPath;
}
}
}
return $phpDocumentorPath;
}
}
phing-2.14.0/tasks/ext/phpdoc/PhingPhpDocumentorErrorTracker.php 0000664 0001750 0001750 00000006675 12670364674 024566 0 ustar michiel michiel .
*/
require_once 'PhpDocumentor/phpDocumentor/Errors.inc';
/**
* Phing subclass of the ErrorTracker class provided with PhpDocumentor to work around limitations in PhpDocumentor API.
*
* This class is necessary because PhpDocumentor does directly output errors and
* warnings occurred during testing for undocumented elements to stdout.
* This class is injected globally to force PhpDocumentor to use phing's logging
* mechanism.
*
* Obviously this is far from ideal, but there's also no solution given the inflexibility of the
* PhpDocumentor design.
*
* @author Timo A. Hummel @author felicitus
* @version $Id: 33771f28a2886e13a8d3c38864d6758311c3e18d $
* @package phing.tasks.ext.phpdoc
*/
class PhingPhpDocumentorErrorTracker extends ErrorTracker
{
/**
* @var object Reference to the task we're called with
*/
private $task;
/**
* Outputs a warning. This is an almost 1:1 copy from PhpDocumentor,
* we're just processing the warning text and send it to phing's logger.
*
* @param $num integer Number of parameters
* @return nothing
*/
public function addWarning($num)
{
$a = array('', '', '', '');
if (func_num_args() > 1) {
for ($i = 1; $i < func_num_args(); $i++) {
$a[$i - 1] = func_get_arg($i);
}
}
$message = sprintf($GLOBALS['phpDocumentor_warning_descrip'][$num], $a[0], $a[1], $a[2], $a[3]);
$this->task->log($message, Project::MSG_WARN);
}
/**
* Outputs an error. This is an almost 1:1 copy from PhpDocumentor,
* we're just processing the error text and send it to phing's logger.
*
* @param $num integer Number of parameters
* @return nothing
*/
public function addError($num)
{
$a = array('', '', '', '');
if (func_num_args() > 1) {
for ($i = 1; $i < func_num_args(); $i++) {
$a[$i - 1] = func_get_arg($i);
}
}
$message = sprintf($GLOBALS['phpDocumentor_error_descrip'][$num], $a[0], $a[1], $a[2], $a[3]);
$this->task->log($message, Project::MSG_ERR);
}
/**
* Sets the task we're working with. This is necessary since we need to be
* able to call the method "log".
*
* @param object $task The task we're working with
* @return nothing
*/
public function setTask($task)
{
$this->task = $task;
}
}
phing-2.14.0/tasks/ext/CapsuleTask.php 0000664 0001750 0001750 00000036350 12670364674 017416 0 ustar michiel michiel .
*/
include_once 'phing/Task.php';
include_once 'phing/BuildException.php';
include_once 'phing/lib/Capsule.php';
include_once 'phing/util/StringHelper.php';
/**
* A phing task for generating output by using Capsule.
*
* This is based on the interface to TexenTask from Apache's Velocity engine.
*
* @author Hans Lellelid
*
* @package phing.tasks.ext
*/
class CapsuleTask extends Task
{
/**
* Capsule "template" engine.
* @var Capsule
*/
protected $context;
/**
* Any vars assigned via the build file.
* @var array AssignedVar[]
*/
protected $assignedVars = array();
/**
* This is the control template that governs the output.
* It may or may not invoke the services of worker
* templates.
* @var string
*/
protected $controlTemplate;
/**
* This is where Velocity will look for templates
* using the file template loader.
* @var string
*/
protected $templatePath;
/**
* This is where texen will place all the output
* that is a product of the generation process.
* @var string
*/
protected $outputDirectory;
/**
* This is the file where the generated text
* will be placed.
* @var string
*/
protected $outputFile;
/**
*
* These are properties that are fed into the
* initial context from a properties file. This
* is simply a convenient way to set some values
* that you wish to make available in the context.
*
*
* These values are not critical, like the template path
* or output path, but allow a convenient way to
* set a value that may be specific to a particular
* generation task.
*
*
* For example, if you are generating scripts to allow
* user to automatically create a database, then
* you might want the $databaseName
* to be placed
* in the initial context so that it is available
* in a script that might look something like the
* following:
*
* #!bin/sh
*
* echo y | mysqladmin create $databaseName
* $databaseName isn't critical to
* output, and you obviously don't want to change
* the ant task to simply take a database name.
* So initial context values can be set with
* properties file.
*
* @var array
*/
protected $contextProperties;
// -----------------------------------------------------------------------
// The following getters & setters are used by phing to set properties
// specified in the XML for the capsule task.
// -----------------------------------------------------------------------
/**
* [REQUIRED] Set the control template for the
* generating process.
* @param string $controlTemplate
* @return void
*/
public function setControlTemplate($controlTemplate)
{
$this->controlTemplate = $controlTemplate;
}
/**
* Get the control template for the
* generating process.
* @return string
*/
public function getControlTemplate()
{
return $this->controlTemplate;
}
/**
* [REQUIRED] Set the path where Velocity will look
* for templates using the file template
* loader.
* @param $templatePath
* @return void
*/
public function setTemplatePath($templatePath)
{
$resolvedPath = "";
$tok = strtok($templatePath, ",");
while ($tok) {
// resolve relative path from basedir and leave
// absolute path untouched.
$fullPath = $this->project->resolveFile($tok);
$cpath = $fullPath->getCanonicalPath();
if ($cpath === false) {
$this->log("Template directory does not exist: " . $fullPath->getAbsolutePath());
} else {
$resolvedPath .= $cpath;
}
$tok = strtok(",");
if ($tok) {
$resolvedPath .= ",";
}
}
$this->templatePath = $resolvedPath;
}
/**
* Get the path where Velocity will look
* for templates using the file template
* loader.
* @return string
*/
public function getTemplatePath()
{
return $this->templatePath;
}
/**
* [REQUIRED] Set the output directory. It will be
* created if it doesn't exist.
* @param PhingFile $outputDirectory
* @return void
* @throws Exception
*/
public function setOutputDirectory(PhingFile $outputDirectory)
{
try {
if (!$outputDirectory->exists()) {
$this->log(
"Output directory does not exist, creating: " . $outputDirectory->getPath(),
Project::MSG_VERBOSE
);
if (!$outputDirectory->mkdirs()) {
throw new IOException("Unable to create Ouptut directory: " . $outputDirectory->getAbsolutePath());
}
}
$this->outputDirectory = $outputDirectory->getCanonicalPath();
} catch (IOException $ioe) {
throw new BuildException($ioe);
}
}
/**
* Get the output directory.
* @return string
*/
public function getOutputDirectory()
{
return $this->outputDirectory;
}
/**
* [REQUIRED] Set the output file for the
* generation process.
* @param string $outputFile (TODO: change this to File)
* @return void
*/
public function setOutputFile($outputFile)
{
$this->outputFile = $outputFile;
}
/**
* Get the output file for the
* generation process.
* @return string
*/
public function getOutputFile()
{
return $this->outputFile;
}
/**
* Set the context properties that will be
* fed into the initial context be the
* generating process starts.
* @param string $file
* @throws BuildException
* @return void
*/
public function setContextProperties($file)
{
$sources = explode(",", $file);
$this->contextProperties = new Properties();
// Always try to get the context properties resource
// from a file first. Templates may be taken from a JAR
// file but the context properties resource may be a
// resource in the filesystem. If this fails than attempt
// to get the context properties resource from the
// classpath.
for ($i = 0, $sourcesLength = count($sources); $i < $sourcesLength; $i++) {
$source = new Properties();
try {
// resolve relative path from basedir and leave
// absolute path untouched.
$fullPath = $this->project->resolveFile($sources[$i]);
$this->log("Using contextProperties file: " . $fullPath->toString());
$source->load($fullPath);
} catch (Exception $e) {
throw new BuildException("Context properties file " . $sources[$i] .
" could not be found in the file system!");
}
$keys = $source->keys();
foreach ($keys as $key) {
$name = $key;
$value = $this->project->replaceProperties($source->getProperty($name));
$this->contextProperties->setProperty($name, $value);
}
}
}
/**
* Get the context properties that will be
* fed into the initial context be the
* generating process starts.
* @return Properties
*/
public function getContextProperties()
{
return $this->contextProperties;
}
/**
* Creates an "AssignedVar" class.
*/
public function createAssign()
{
$a = new AssignedVar();
$this->assignedVars[] = $a;
return $a;
}
// ---------------------------------------------------------------
// End of XML setters & getters
// ---------------------------------------------------------------
/**
* Creates a Smarty object.
*
* @return Capsule initialized (cleared) Smarty context.
* @throws Exception the execute method will catch
* and rethrow as a BuildException
*/
public function initControlContext()
{
$this->context->clear();
foreach ($this->assignedVars as $var) {
$this->context->put($var->getName(), $var->getValue());
}
return $this->context;
}
/**
* Execute the input script with Velocity
*
* @throws BuildException
* BuildExceptions are thrown when required attributes are missing.
* Exceptions thrown by Velocity are rethrown as BuildExceptions.
*/
public function main()
{
// Make sure the template path is set.
if (empty($this->templatePath)) {
throw new BuildException("The template path needs to be defined!");
}
// Make sure the control template is set.
if ($this->controlTemplate === null) {
throw new BuildException("The control template needs to be defined!");
}
// Make sure the output directory is set.
if ($this->outputDirectory === null) {
throw new BuildException("The output directory needs to be defined!");
}
// Make sure there is an output file.
if ($this->outputFile === null) {
throw new BuildException("The output file needs to be defined!");
}
// Setup Smarty runtime.
// Smarty uses one object to store properties and to store
// the context for the template (unlike Velocity). We setup this object, calling it
// $this->context, and then initControlContext simply zeros out
// any assigned variables.
$this->context = new Capsule();
if ($this->templatePath !== null) {
$this->log("Using templatePath: " . $this->templatePath);
$this->context->setTemplatePath($this->templatePath);
}
// Make sure the output directory exists, if it doesn't
// then create it.
$outputDir = new PhingFile($this->outputDirectory);
if (!$outputDir->exists()) {
$this->log("Output directory does not exist, creating: " . $outputDir->getAbsolutePath());
$outputDir->mkdirs();
}
$this->context->setOutputDirectory($outputDir->getAbsolutePath());
$path = $this->outputDirectory . DIRECTORY_SEPARATOR . $this->outputFile;
$this->log("Generating to file " . $path);
//$writer = new FileWriter($path);
// The generator and the output path should
// be placed in the init context here and
// not in the generator class itself.
$c = $this->initControlContext();
// Set any variables that need to always
// be loaded
$this->populateInitialContext($c);
// Feed all the options into the initial
// control context so they are available
// in the control/worker templates.
if ($this->contextProperties !== null) {
foreach ($this->contextProperties->keys() as $property) {
$value = $this->contextProperties->getProperty($property);
// Special exception (from Texen)
// for properties ending in file.contents:
// in that case we dump the contents of the file
// as the "value" for the Property.
if (preg_match('/file\.contents$/', $property)) {
// pull in contents of file specified
$property = substr($property, 0, strpos($property, "file.contents") - 1);
// reset value, and then
// read in the contents of the file into that var
$value = "";
$f = new PhingFile($this->project->resolveFile($value)->getCanonicalPath());
if ($f->exists()) {
$fr = new FileReader($f);
$fr->readInto($value);
}
} // if ends with file.contents
if (StringHelper::isBoolean($value)) {
$value = StringHelper::booleanValue($value);
}
$c->put($property, $value);
} // foreach property
} // if contextProperties !== null
try {
$this->log("Parsing control template: " . $this->controlTemplate);
$c->parse($this->controlTemplate, $path);
} catch (Exception $ioe) {
throw new BuildException("Cannot write parsed template: " . $ioe->getMessage());
}
$this->cleanup();
}
/**
* Place useful objects into the initial context.
*
*
* @param Capsule $context The context to populate, as retrieved from
* {@link #initControlContext()}.
* @return void
* @throws Exception Error while populating context. The {@link
* #main()} method will catch and rethrow as a
* BuildException.
*/
protected function populateInitialContext(Capsule $context)
{
$this->context->put("now", strftime("%c", time()));
$this->context->put("task", $this);
}
/**
* A hook method called at the end of {@link #execute()} which can
* be overridden to perform any necessary cleanup activities (such
* as the release of database connections, etc.). By default,
* does nothing.
*
* @return void
*/
protected function cleanup()
{
}
}
/**
* An "inner" class for holding assigned var values.
* May be need to expand beyond name/value in the future.
*
* @package phing.tasks.ext
*/
class AssignedVar
{
private $name;
private $value;
/**
* @param string $v
*/
public function setName($v)
{
$this->name = $v;
}
/**
* @param mixed $v
*/
public function setValue($v)
{
$this->value = $v;
}
/**
* @return string
*/
public function getName()
{
return $this->name;
}
/**
* @return mixed
*/
public function getValue()
{
return $this->value;
}
}
phing-2.14.0/tasks/ext/coverage/CoverageReportTask.php 0000775 0001750 0001750 00000046376 12670364674 022560 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/system/io/PhingFile.php';
require_once 'phing/system/io/Writer.php';
require_once 'phing/system/util/Properties.php';
require_once 'phing/tasks/ext/phpunit/PHPUnitUtil.php';
require_once 'phing/tasks/ext/coverage/CoverageReportTransformer.php';
/**
* Transforms information in a code coverage database to XML
*
* @author Michiel Rook
* @version $Id: 2f73afc3401097333c7f187eacb79de9e16a6f35 $
* @package phing.tasks.ext.coverage
* @since 2.1.0
*/
class CoverageReportTask extends Task
{
private $outfile = "coverage.xml";
private $transformers = array();
/** the classpath to use (optional) */
private $classpath = null;
/** the path to the GeSHi library (optional) */
private $geshipath = "";
/** the path to the GeSHi language files (optional) */
private $geshilanguagespath = "";
/**
* @param Path $classpath
*/
public function setClasspath(Path $classpath)
{
if ($this->classpath === null) {
$this->classpath = $classpath;
} else {
$this->classpath->append($classpath);
}
}
/**
* @return null|Path
*/
public function createClasspath()
{
$this->classpath = new Path();
return $this->classpath;
}
/**
* @param $path
*/
public function setGeshiPath($path)
{
$this->geshipath = $path;
}
/**
* @param $path
*/
public function setGeshiLanguagesPath($path)
{
$this->geshilanguagespath = $path;
}
/**
*
*/
public function __construct()
{
$this->doc = new DOMDocument();
$this->doc->encoding = 'UTF-8';
$this->doc->formatOutput = true;
$this->doc->appendChild($this->doc->createElement('snapshot'));
}
/**
* @param $outfile
*/
public function setOutfile($outfile)
{
$this->outfile = $outfile;
}
/**
* Generate a report based on the XML created by this task
*/
public function createReport()
{
$transformer = new CoverageReportTransformer($this);
$this->transformers[] = $transformer;
return $transformer;
}
/**
* @param $packageName
* @return null
*/
protected function getPackageElement($packageName)
{
$packages = $this->doc->documentElement->getElementsByTagName('package');
foreach ($packages as $package) {
if ($package->getAttribute('name') == $packageName) {
return $package;
}
}
return null;
}
/**
* @param $packageName
* @param $element
*/
protected function addClassToPackage($packageName, $element)
{
$package = $this->getPackageElement($packageName);
if ($package === null) {
$package = $this->doc->createElement('package');
$package->setAttribute('name', $packageName);
$this->doc->documentElement->appendChild($package);
}
$package->appendChild($element);
}
/**
* Adds a subpackage to their package
*
* @param string $packageName The name of the package
* @param string $subpackageName The name of the subpackage
*
* @author Benjamin Schultz
* @return void
*/
protected function addSubpackageToPackage($packageName, $subpackageName)
{
$package = $this->getPackageElement($packageName);
$subpackage = $this->getSubpackageElement($subpackageName);
if ($package === null) {
$package = $this->doc->createElement('package');
$package->setAttribute('name', $packageName);
$this->doc->documentElement->appendChild($package);
}
if ($subpackage === null) {
$subpackage = $this->doc->createElement('subpackage');
$subpackage->setAttribute('name', $subpackageName);
}
$package->appendChild($subpackage);
}
/**
* Returns the subpackage element
*
* @param string $subpackageName The name of the subpackage
*
* @author Benjamin Schultz
* @return DOMNode|null null when no DOMNode with the given name exists
*/
protected function getSubpackageElement($subpackageName)
{
$subpackages = $this->doc->documentElement->getElementsByTagName('subpackage');
foreach ($subpackages as $subpackage) {
if ($subpackage->getAttribute('name') == $subpackageName) {
return $subpackage;
}
}
return null;
}
/**
* Adds a class to their subpackage
*
* @param string $classname The name of the class
* @param DOMNode $element The dom node to append to the subpackage element
*
* @author Benjamin Schultz
* @return void
*/
protected function addClassToSubpackage($classname, $element)
{
$subpackageName = PHPUnitUtil::getSubpackageName($classname);
$subpackage = $this->getSubpackageElement($subpackageName);
if ($subpackage === null) {
$subpackage = $this->doc->createElement('subpackage');
$subpackage->setAttribute('name', $subpackageName);
$this->doc->documentElement->appendChild($subpackage);
}
$subpackage->appendChild($element);
}
/**
* @param $source
* @return string
*/
protected function stripDiv($source)
{
$openpos = strpos($source, "", $openpos);
$line = substr($source, $closepos + 1);
$tagclosepos = strpos($line, "");
$line = substr($line, 0, $tagclosepos);
return $line;
}
/**
* @param $filename
* @return array
*/
protected function highlightSourceFile($filename)
{
if ($this->geshipath) {
require_once $this->geshipath . '/geshi.php';
$source = file_get_contents($filename);
$geshi = new GeSHi($source, 'php', $this->geshilanguagespath);
$geshi->enable_line_numbers(GESHI_NORMAL_LINE_NUMBERS);
$geshi->enable_strict_mode(true);
$geshi->enable_classes(true);
$geshi->set_url_for_keyword_group(3, '');
$html = $geshi->parse_code();
$lines = preg_split("##", $html);
// skip first and last line
array_pop($lines);
array_shift($lines);
$lines = array_filter($lines);
$lines = array_map(array($this, 'stripDiv'), $lines);
return $lines;
} else {
$lines = file($filename);
for ($i = 0; $i < count($lines); $i++) {
$line = $lines[$i];
$line = rtrim($line);
if (function_exists('mb_check_encoding') && mb_check_encoding($line, 'UTF-8')) {
$lines[$i] = $line;
} else {
if (function_exists('mb_convert_encoding')) {
$lines[$i] = mb_convert_encoding($line, 'UTF-8');
} else {
$lines[$i] = utf8_encode($line);
}
}
}
return $lines;
}
}
/**
* @param $filename
* @param $coverageInformation
* @param int $classStartLine
* @return DOMElement
*/
protected function transformSourceFile($filename, $coverageInformation, $classStartLine = 1)
{
$sourceElement = $this->doc->createElement('sourcefile');
$sourceElement->setAttribute('name', basename($filename));
/**
* Add original/full filename to document
*/
$sourceElement->setAttribute('sourcefile', $filename);
$filelines = $this->highlightSourceFile($filename);
$linenr = 1;
foreach ($filelines as $line) {
$lineElement = $this->doc->createElement('sourceline');
$lineElement->setAttribute(
'coveredcount',
(isset($coverageInformation[$linenr]) ? $coverageInformation[$linenr] : '0')
);
if ($linenr == $classStartLine) {
$lineElement->setAttribute('startclass', 1);
}
$textnode = $this->doc->createTextNode($line);
$lineElement->appendChild($textnode);
$sourceElement->appendChild($lineElement);
$linenr++;
}
return $sourceElement;
}
/**
* Transforms the coverage information
*
* @param string $filename The filename
* @param array $coverageInformation Array with covergae information
*
* @author Michiel Rook
* @author Benjamin Schultz
* @return void
*/
protected function transformCoverageInformation($filename, $coverageInformation)
{
$classes = PHPUnitUtil::getDefinedClasses($filename, $this->classpath);
if (is_array($classes)) {
foreach ($classes as $classname) {
$reflection = new ReflectionClass($classname);
$methods = $reflection->getMethods();
if (method_exists($reflection, 'getShortName')) {
$className = $reflection->getShortName();
} else {
$className = $reflection->getName();
}
$classElement = $this->doc->createElement('class');
$classElement->setAttribute('name', $className);
$packageName = PHPUnitUtil::getPackageName($reflection->getName());
$subpackageName = PHPUnitUtil::getSubpackageName($reflection->getName());
if ($subpackageName !== null) {
$this->addSubpackageToPackage($packageName, $subpackageName);
$this->addClassToSubpackage($className, $classElement);
} else {
$this->addClassToPackage($packageName, $classElement);
}
$classStartLine = $reflection->getStartLine();
$methodscovered = 0;
$methodcount = 0;
// Strange PHP5 reflection bug, classes without parent class or implemented interfaces seem to start one line off
if ($reflection->getParentClass() == null && count($reflection->getInterfaces()) == 0) {
unset($coverageInformation[$classStartLine + 1]);
} else {
unset($coverageInformation[$classStartLine]);
}
// Remove out-of-bounds info
unset($coverageInformation[0]);
reset($coverageInformation);
foreach ($methods as $method) {
// PHP5 reflection considers methods of a parent class to be part of a subclass, we don't
if ($method->getDeclaringClass()->getName() != $reflection->getName()) {
continue;
}
// small fix for XDEBUG_CC_UNUSED
if (isset($coverageInformation[$method->getStartLine()])) {
unset($coverageInformation[$method->getStartLine()]);
}
if (isset($coverageInformation[$method->getEndLine()])) {
unset($coverageInformation[$method->getEndLine()]);
}
if ($method->isAbstract()) {
continue;
}
$linenr = key($coverageInformation);
while ($linenr !== null && $linenr < $method->getStartLine()) {
next($coverageInformation);
$linenr = key($coverageInformation);
}
$methodCoveredCount = 0;
$methodTotalCount = 0;
$methodHasCoveredLine = false;
while ($linenr !== null && $linenr <= $method->getEndLine()) {
$methodTotalCount++;
$methodHasCoveredLine = true;
// set covered when CODE is other than -1 (not executed)
if ($coverageInformation[$linenr] > 0 || $coverageInformation[$linenr] == -2) {
$methodCoveredCount++;
}
next($coverageInformation);
$linenr = key($coverageInformation);
}
if (($methodTotalCount == $methodCoveredCount) && $methodHasCoveredLine) {
$methodscovered++;
}
$methodcount++;
}
$statementcount = count(
array_filter(
$coverageInformation,
create_function('$var', 'return ($var != -2);')
)
);
$statementscovered = count(
array_filter(
$coverageInformation,
create_function('$var', 'return ($var >= 0);')
)
);
$classElement->appendChild(
$this->transformSourceFile($filename, $coverageInformation, $classStartLine)
);
$classElement->setAttribute('methodcount', $methodcount);
$classElement->setAttribute('methodscovered', $methodscovered);
$classElement->setAttribute('statementcount', $statementcount);
$classElement->setAttribute('statementscovered', $statementscovered);
$classElement->setAttribute('totalcount', $methodcount + $statementcount);
$classElement->setAttribute('totalcovered', $methodscovered + $statementscovered);
}
}
}
protected function calculateStatistics()
{
$packages = $this->doc->documentElement->getElementsByTagName('package');
$totalmethodcount = 0;
$totalmethodscovered = 0;
$totalstatementcount = 0;
$totalstatementscovered = 0;
foreach ($packages as $package) {
$methodcount = 0;
$methodscovered = 0;
$statementcount = 0;
$statementscovered = 0;
$subpackages = $package->getElementsByTagName('subpackage');
foreach ($subpackages as $subpackage) {
$subpackageMethodCount = 0;
$subpackageMethodsCovered = 0;
$subpackageStatementCount = 0;
$subpackageStatementsCovered = 0;
$subpackageClasses = $subpackage->getElementsByTagName('class');
foreach ($subpackageClasses as $subpackageClass) {
$subpackageMethodCount += $subpackageClass->getAttribute('methodcount');
$subpackageMethodsCovered += $subpackageClass->getAttribute('methodscovered');
$subpackageStatementCount += $subpackageClass->getAttribute('statementcount');
$subpackageStatementsCovered += $subpackageClass->getAttribute('statementscovered');
}
$subpackage->setAttribute('methodcount', $subpackageMethodCount);
$subpackage->setAttribute('methodscovered', $subpackageMethodsCovered);
$subpackage->setAttribute('statementcount', $subpackageStatementCount);
$subpackage->setAttribute('statementscovered', $subpackageStatementsCovered);
$subpackage->setAttribute('totalcount', $subpackageMethodCount + $subpackageStatementCount);
$subpackage->setAttribute('totalcovered', $subpackageMethodsCovered + $subpackageStatementsCovered);
}
$classes = $package->getElementsByTagName('class');
foreach ($classes as $class) {
$methodcount += $class->getAttribute('methodcount');
$methodscovered += $class->getAttribute('methodscovered');
$statementcount += $class->getAttribute('statementcount');
$statementscovered += $class->getAttribute('statementscovered');
}
$package->setAttribute('methodcount', $methodcount);
$package->setAttribute('methodscovered', $methodscovered);
$package->setAttribute('statementcount', $statementcount);
$package->setAttribute('statementscovered', $statementscovered);
$package->setAttribute('totalcount', $methodcount + $statementcount);
$package->setAttribute('totalcovered', $methodscovered + $statementscovered);
$totalmethodcount += $methodcount;
$totalmethodscovered += $methodscovered;
$totalstatementcount += $statementcount;
$totalstatementscovered += $statementscovered;
}
$this->doc->documentElement->setAttribute('methodcount', $totalmethodcount);
$this->doc->documentElement->setAttribute('methodscovered', $totalmethodscovered);
$this->doc->documentElement->setAttribute('statementcount', $totalstatementcount);
$this->doc->documentElement->setAttribute('statementscovered', $totalstatementscovered);
$this->doc->documentElement->setAttribute('totalcount', $totalmethodcount + $totalstatementcount);
$this->doc->documentElement->setAttribute('totalcovered', $totalmethodscovered + $totalstatementscovered);
}
public function main()
{
$coverageDatabase = $this->project->getProperty('coverage.database');
if (!$coverageDatabase) {
throw new BuildException("Property coverage.database is not set - please include coverage-setup in your build file");
}
$database = new PhingFile($coverageDatabase);
$this->log("Transforming coverage report");
$props = new Properties();
$props->load($database);
foreach ($props->keys() as $filename) {
$file = unserialize($props->getProperty($filename));
$this->transformCoverageInformation($file['fullname'], $file['coverage']);
}
$this->calculateStatistics();
$this->doc->save($this->outfile);
foreach ($this->transformers as $transformer) {
$transformer->setXmlDocument($this->doc);
$transformer->transform();
}
}
}
phing-2.14.0/tasks/ext/coverage/CoverageMerger.php 0000775 0001750 0001750 00000012450 12670364674 021665 0 ustar michiel michiel .
*/
require_once 'phing/system/util/Properties.php';
/**
* Saves coverage output of the test to a specified database
*
* @author Michiel Rook
* @version $Id: 18a66018595b27816f2bd0ac5f2d67a42ea16416 $
* @package phing.tasks.ext.coverage
* @since 2.1.0
*/
class CoverageMerger
{
/**
* @param $left
* @param $right
* @return array
*/
private static function mergeCodeCoverage($left, $right)
{
$coverageMerged = array();
reset($left);
reset($right);
while (current($left) !== false && current($right) !== false) {
$linenr_left = key($left);
$linenr_right = key($right);
if ($linenr_left < $linenr_right) {
$coverageMerged[$linenr_left] = current($left);
next($left);
} elseif ($linenr_right < $linenr_left) {
$coverageMerged[$linenr_right] = current($right);
next($right);
} else {
if ((current($left) < 0) || (current($right) < 0)) {
$coverageMerged[$linenr_right] = current($right);
} else {
$coverageMerged[$linenr_right] = current($left) + current($right);
}
next($left);
next($right);
}
}
while (current($left) !== false) {
$coverageMerged[key($left)] = current($left);
next($left);
}
while (current($right) !== false) {
$coverageMerged[key($right)] = current($right);
next($right);
}
return $coverageMerged;
}
/**
* @param Project $project
* @return Properties
* @throws BuildException
*/
protected static function _getDatabase($project)
{
$coverageDatabase = $project->getProperty('coverage.database');
if (!$coverageDatabase) {
throw new BuildException("Property coverage.database is not set - please include coverage-setup in your build file");
}
$database = new PhingFile($coverageDatabase);
$props = new Properties();
$props->load($database);
return $props;
}
/**
* @param $project
* @return array
* @throws BuildException
*/
public static function getWhiteList($project)
{
$whitelist = array();
$props = self::_getDatabase($project);
foreach ($props->getProperties() as $property) {
$data = unserialize($property);
$whitelist[] = $data['fullname'];
}
return $whitelist;
}
/**
* @param $project
* @param $codeCoverageInformation
* @throws BuildException
* @throws IOException
*/
public static function merge($project, $codeCoverageInformation)
{
$props = self::_getDatabase($project);
$coverageTotal = $codeCoverageInformation;
foreach ($coverageTotal as $filename => $data) {
$lines = array();
$filename = strtolower($filename);
if ($props->getProperty($filename) != null) {
foreach ($data as $_line => $_data) {
if ($_data === null) {
continue;
}
if (is_array($_data)) {
$count = count($_data);
if ($count == 0) {
$count = -1;
}
} else {
if ($_data == -1) {
// not executed
$count = -1;
} else {
if ($_data == -2) {
// dead code
$count = -2;
}
}
}
$lines[$_line] = $count;
}
ksort($lines);
$file = unserialize($props->getProperty($filename));
$left = $file['coverage'];
$coverageMerged = CoverageMerger::mergeCodeCoverage($left, $lines);
$file['coverage'] = $coverageMerged;
$props->setProperty($filename, serialize($file));
}
}
$props->store();
}
}
phing-2.14.0/tasks/ext/coverage/CoverageMergerTask.php 0000775 0001750 0001750 00000005434 12670364674 022514 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/system/io/PhingFile.php';
require_once 'phing/system/io/Writer.php';
require_once 'phing/system/util/Properties.php';
require_once 'phing/tasks/ext/coverage/CoverageMerger.php';
/**
* Merges code coverage snippets into a code coverage database
*
* @author Michiel Rook
* @version $Id: 6d4732d2b352c992dc03cd92cd83ad1b81bf9e45 $
* @package phing.tasks.ext.coverage
* @since 2.1.0
*/
class CoverageMergerTask extends Task
{
/** the list of filesets containing the .php filename rules */
private $filesets = array();
/**
* Add a new fileset containing the .php files to process
*
* @param FileSet the new fileset containing .php files
*/
public function addFileSet(FileSet $fileset)
{
$this->filesets[] = $fileset;
}
/**
* Iterate over all filesets and return all the filenames.
*
* @return array an array of filenames
*/
private function getFilenames()
{
$files = array();
foreach ($this->filesets as $fileset) {
$ds = $fileset->getDirectoryScanner($this->project);
$ds->scan();
$includedFiles = $ds->getIncludedFiles();
foreach ($includedFiles as $file) {
$fs = new PhingFile(basename($ds->getBaseDir()), $file);
$files[] = $fs->getAbsolutePath();
}
}
return $files;
}
public function main()
{
$files = $this->getFilenames();
$this->log("Merging " . count($files) . " coverage files");
foreach ($files as $file) {
$coverageInformation = unserialize(file_get_contents($file));
CoverageMerger::merge($this->project, array($coverageInformation));
}
}
}
phing-2.14.0/tasks/ext/coverage/CoverageThresholdTask.php 0000664 0001750 0001750 00000035210 12670364674 023217 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/system/io/PhingFile.php';
require_once 'phing/system/util/Properties.php';
require_once 'phing/types/Excludes.php';
/**
* Stops the build if any of the specified coverage threshold was not reached
*
* @author Benjamin Schultz
* @version $Id: 1cf68f1a4ec652811a5fd9db8353cae9a88ee03e $
* @package phing.tasks.ext.coverage
* @since 2.4.1
*/
class CoverageThresholdTask extends Task
{
/**
* Holds an optional classpath
*
* @var Path
*/
private $_classpath = null;
/**
* Holds the exclusions
*
* @var Excludes
*/
private $_excludes = null;
/**
* Holds an optional database file
*
* @var PhingFile
*/
private $_database = null;
/**
* Holds the coverage threshold for the entire project
*
* @var integer
*/
private $_perProject = 25;
/**
* Holds the coverage threshold for any class
*
* @var integer
*/
private $_perClass = 25;
/**
* Holds the coverage threshold for any method
*
* @var integer
*/
private $_perMethod = 25;
/**
* Holds the minimum found coverage value for a class
*
* @var integer
*/
private $_minClassCoverageFound = null;
/**
* Holds the minimum found coverage value for a method
*
* @var integer
*/
private $_minMethodCoverageFound = null;
/**
* Number of statements in the entire project
*
* @var integer
*/
private $_projectStatementCount = 0;
/**
* Number of covered statements in the entire project
*
* @var integer
*/
private $_projectStatementsCovered = 0;
/**
* Whether to enable detailed logging
*
* @var boolean
*/
private $_verbose = false;
/**
* Sets an optional classpath
*
* @param Path $classpath The classpath
*/
public function setClasspath(Path $classpath)
{
if ($this->_classpath === null) {
$this->_classpath = $classpath;
} else {
$this->_classpath->append($classpath);
}
}
/**
* Sets the optional coverage database to use
*
* @param PhingFile The database file
*/
public function setDatabase(PhingFile $database)
{
$this->_database = $database;
}
/**
* Create classpath object
*
* @return Path
*/
public function createClasspath()
{
$this->_classpath = new Path();
return $this->_classpath;
}
/**
* Sets the coverage threshold for entire project
*
* @param integer $threshold Coverage threshold for entire project
*/
public function setPerProject($threshold)
{
$this->_perProject = $threshold;
}
/**
* Sets the coverage threshold for any class
*
* @param integer $threshold Coverage threshold for any class
*/
public function setPerClass($threshold)
{
$this->_perClass = $threshold;
}
/**
* Sets the coverage threshold for any method
*
* @param integer $threshold Coverage threshold for any method
*/
public function setPerMethod($threshold)
{
$this->_perMethod = $threshold;
}
/**
* Sets whether to enable detailed logging or not
*
* @param boolean $verbose
*/
public function setVerbose($verbose)
{
$this->_verbose = StringHelper::booleanValue($verbose);
}
/**
* Filter covered statements
*
* @param integer $var Coverage CODE/count
* @return boolean
*/
protected function filterCovered($var)
{
return ($var >= 0 || $var === -2);
}
/**
* Create excludes object
*
* @return Excludes
*/
public function createExcludes()
{
$this->_excludes = new Excludes($this->project);
return $this->_excludes;
}
/**
* Calculates the coverage threshold
*
* @param string $filename The filename to analyse
* @param array $coverageInformation Array with coverage information
* @throws BuildException
*/
protected function calculateCoverageThreshold($filename, $coverageInformation)
{
$classes = PHPUnitUtil::getDefinedClasses($filename, $this->_classpath);
if (is_array($classes)) {
foreach ($classes as $className) {
// Skip class if excluded from coverage threshold validation
if ($this->_excludes !== null) {
if (in_array($className, $this->_excludes->getExcludedClasses())) {
continue;
}
}
$reflection = new ReflectionClass($className);
$classStartLine = $reflection->getStartLine();
// Strange PHP5 reflection bug, classes without parent class
// or implemented interfaces seem to start one line off
if ($reflection->getParentClass() === null
&& count($reflection->getInterfaces()) === 0
) {
unset($coverageInformation[$classStartLine + 1]);
} else {
unset($coverageInformation[$classStartLine]);
}
reset($coverageInformation);
$methods = $reflection->getMethods();
foreach ($methods as $method) {
// PHP5 reflection considers methods of a parent class
// to be part of a subclass, we don't
if ($method->getDeclaringClass()->getName() != $reflection->getName()) {
continue;
}
// Skip method if excluded from coverage threshold validation
if ($this->_excludes !== null) {
$excludedMethods = $this->_excludes->getExcludedMethods();
if (isset($excludedMethods[$className])) {
if (in_array($method->getName(), $excludedMethods[$className])
|| in_array($method->getName() . '()', $excludedMethods[$className])
) {
continue;
}
}
}
$methodStartLine = $method->getStartLine();
$methodEndLine = $method->getEndLine();
// small fix for XDEBUG_CC_UNUSED
if (isset($coverageInformation[$methodStartLine])) {
unset($coverageInformation[$methodStartLine]);
}
if (isset($coverageInformation[$methodEndLine])) {
unset($coverageInformation[$methodEndLine]);
}
if ($method->isAbstract()) {
continue;
}
$lineNr = key($coverageInformation);
while ($lineNr !== null && $lineNr < $methodStartLine) {
next($coverageInformation);
$lineNr = key($coverageInformation);
}
$methodStatementsCovered = 0;
$methodStatementCount = 0;
while ($lineNr !== null && $lineNr <= $methodEndLine) {
$methodStatementCount++;
$lineCoverageInfo = $coverageInformation[$lineNr];
// set covered when CODE is other than -1 (not executed)
if ($lineCoverageInfo > 0 || $lineCoverageInfo === -2) {
$methodStatementsCovered++;
}
next($coverageInformation);
$lineNr = key($coverageInformation);
}
if ($methodStatementCount > 0) {
$methodCoverage = ($methodStatementsCovered
/ $methodStatementCount) * 100;
} else {
$methodCoverage = 0;
}
if ($methodCoverage < $this->_perMethod
&& !$method->isAbstract()
) {
throw new BuildException(
'The coverage (' . round($methodCoverage, 2) . '%) '
. 'for method "' . $method->getName() . '" is lower'
. ' than the specified threshold ('
. $this->_perMethod . '%), see file: "'
. $filename . '"'
);
} elseif ($methodCoverage < $this->_perMethod
&& $method->isAbstract()
&& $this->_verbose === true
) {
$this->log(
'Skipped coverage threshold for abstract method "'
. $method->getName() . '"'
);
}
// store the minimum coverage value for logging (see #466)
if ($this->_minMethodCoverageFound !== null) {
if ($this->_minMethodCoverageFound > $methodCoverage) {
$this->_minMethodCoverageFound = $methodCoverage;
}
} else {
$this->_minMethodCoverageFound = $methodCoverage;
}
}
$classStatementCount = count($coverageInformation);
$classStatementsCovered = count(
array_filter(
$coverageInformation,
array($this, 'filterCovered')
)
);
if ($classStatementCount > 0) {
$classCoverage = ($classStatementsCovered
/ $classStatementCount) * 100;
} else {
$classCoverage = 0;
}
if ($classCoverage < $this->_perClass
&& !$reflection->isAbstract()
) {
throw new BuildException(
'The coverage (' . round($classCoverage, 2) . '%) for class "'
. $reflection->getName() . '" is lower than the '
. 'specified threshold (' . $this->_perClass . '%), '
. 'see file: "' . $filename . '"'
);
} elseif ($classCoverage < $this->_perClass
&& $reflection->isAbstract()
&& $this->_verbose === true
) {
$this->log(
'Skipped coverage threshold for abstract class "'
. $reflection->getName() . '"'
);
}
// store the minimum coverage value for logging (see #466)
if ($this->_minClassCoverageFound !== null) {
if ($this->_minClassCoverageFound > $classCoverage) {
$this->_minClassCoverageFound = $classCoverage;
}
} else {
$this->_minClassCoverageFound = $classCoverage;
}
$this->_projectStatementCount += $classStatementCount;
$this->_projectStatementsCovered += $classStatementsCovered;
}
}
}
public function main()
{
if ($this->_database === null) {
$coverageDatabase = $this->project
->getProperty('coverage.database');
if (!$coverageDatabase) {
throw new BuildException(
'Either include coverage-setup in your build file or set '
. 'the "database" attribute'
);
}
$database = new PhingFile($coverageDatabase);
} else {
$database = $this->_database;
}
$this->log(
'Calculating coverage threshold: min. '
. $this->_perProject . '% per project, '
. $this->_perClass . '% per class and '
. $this->_perMethod . '% per method is required'
);
$props = new Properties();
$props->load($database);
foreach ($props->keys() as $filename) {
$file = unserialize($props->getProperty($filename));
// Skip file if excluded from coverage threshold validation
if ($this->_excludes !== null) {
if (in_array($file['fullname'], $this->_excludes->getExcludedFiles())) {
continue;
}
}
$this->calculateCoverageThreshold(
$file['fullname'],
$file['coverage']
);
}
if ($this->_projectStatementCount > 0) {
$coverage = ($this->_projectStatementsCovered
/ $this->_projectStatementCount) * 100;
} else {
$coverage = 0;
}
if ($coverage < $this->_perProject) {
throw new BuildException(
'The coverage (' . round($coverage, 2) . '%) for the entire project '
. 'is lower than the specified threshold ('
. $this->_perProject . '%)'
);
}
$this->log(
'Passed coverage threshold. Minimum found coverage values are: '
. round($coverage, 2) . '% per project, '
. round($this->_minClassCoverageFound, 2) . '% per class and '
. round($this->_minMethodCoverageFound, 2) . '% per method'
);
}
}
phing-2.14.0/tasks/ext/coverage/CoverageSetupTask.php 0000775 0001750 0001750 00000011432 12670364674 022366 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/system/io/PhingFile.php';
require_once 'phing/system/io/Writer.php';
require_once 'phing/system/util/Properties.php';
require_once 'phing/tasks/ext/coverage/CoverageMerger.php';
/**
* Initializes a code coverage database
*
* @author Michiel Rook
* @version $Id: bde7020012ba4f24e0d97768c76a5a8af99a6fbb $
* @package phing.tasks.ext.coverage
* @since 2.1.0
*/
class CoverageSetupTask extends Task
{
/** the list of filesets containing the .php filename rules */
private $filesets = array();
/** Any filelists of files containing the .php filenames */
private $filelists = array();
/** the filename of the coverage database */
private $database = "coverage.db";
/** the classpath to use (optional) */
private $classpath = null;
/**
* Add a new fileset containing the .php files to process
*
* @param FileSet the new fileset containing .php files
*/
public function addFileSet(FileSet $fileset)
{
$this->filesets[] = $fileset;
}
/**
* Supports embedded element.
* @return FileList
*/
public function createFileList()
{
$num = array_push($this->filelists, new FileList());
return $this->filelists[$num - 1];
}
/**
* Sets the filename of the coverage database to use
*
* @param string the filename of the database
*/
public function setDatabase($database)
{
$this->database = $database;
}
/**
* @param Path $classpath
*/
public function setClasspath(Path $classpath)
{
if ($this->classpath === null) {
$this->classpath = $classpath;
} else {
$this->classpath->append($classpath);
}
}
/**
* @return null|Path
*/
public function createClasspath()
{
$this->classpath = new Path();
return $this->classpath;
}
/**
* Iterate over all filesets and return the filename of all files.
*
* @return array an array of (basedir, filenames) pairs
*/
private function getFilenames()
{
$files = array();
foreach ($this->filelists as $fl) {
try {
$list = $fl->getFiles($this->project);
foreach ($list as $file) {
$fs = new PhingFile(strval($fl->getDir($this->project)), $file);
$files[] = array('key' => strtolower($fs->getAbsolutePath()), 'fullname' => $fs->getAbsolutePath());
}
} catch (BuildException $be) {
$this->log($be->getMessage(), Project::MSG_WARN);
}
}
foreach ($this->filesets as $fileset) {
$ds = $fileset->getDirectoryScanner($this->project);
$ds->scan();
$includedFiles = $ds->getIncludedFiles();
foreach ($includedFiles as $file) {
$fs = new PhingFile(realpath($ds->getBaseDir()), $file);
$files[] = array('key' => strtolower($fs->getAbsolutePath()), 'fullname' => $fs->getAbsolutePath());
}
}
return $files;
}
public function init()
{
}
public function main()
{
$files = $this->getFilenames();
$this->log("Setting up coverage database for " . count($files) . " files");
$props = new Properties();
foreach ($files as $file) {
$fullname = $file['fullname'];
$filename = $file['key'];
$props->setProperty($filename, serialize(array('fullname' => $fullname, 'coverage' => array())));
}
$dbfile = new PhingFile($this->database);
$props->store($dbfile);
$this->project->setProperty('coverage.database', $dbfile->getAbsolutePath());
}
}
phing-2.14.0/tasks/ext/coverage/CoverageReportTransformer.php 0000775 0001750 0001750 00000012070 12670364674 024140 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/system/io/PhingFile.php';
require_once 'phing/system/io/FileWriter.php';
require_once 'phing/util/ExtendedFileStream.php';
/**
* Transform a Phing/Xdebug code coverage xml report.
* The default transformation generates an html report in framed style.
*
* @author Michiel Rook
* @version $Id: d3a5fbec986f8d4d1fde4875192fb243c82f1e68 $
* @package phing.tasks.ext.coverage
* @since 2.1.0
*/
class CoverageReportTransformer
{
private $task = null;
private $styleDir = "";
/**
* @var PhingFile
*/
private $toDir = "";
private $document = null;
/** title of the project, used in the coverage report */
private $title = "";
/**
* Whether to use the sorttable JavaScript library, defaults to false
* See {@link http://www.kryogenix.org/code/browser/sorttable/)}
*
* @var boolean
*/
private $useSortTable = false;
/**
* @param Task $task
*/
public function __construct(Task $task)
{
$this->task = $task;
}
/**
* @param $styleDir
*/
public function setStyleDir($styleDir)
{
$this->styleDir = $styleDir;
}
/**
* @param PhingFile $toDir
*/
public function setToDir(PhingFile $toDir)
{
$this->toDir = $toDir;
}
/**
* @param $document
*/
public function setXmlDocument($document)
{
$this->document = $document;
}
/**
* Setter for title parameter
* @param $title
*/
public function setTitle($title)
{
$this->title = $title;
}
/**
* Sets whether to use the sorttable JavaScript library, defaults to false
* See {@link http://www.kryogenix.org/code/browser/sorttable/)}
*
* @param boolean $useSortTable
*/
public function setUseSortTable($useSortTable)
{
$this->useSortTable = (boolean) $useSortTable;
}
public function transform()
{
if (!$this->toDir->exists()) {
throw new BuildException("Directory '" . $this->toDir . "' does not exist");
}
$xslfile = $this->getStyleSheet();
$xsl = new DOMDocument();
$xsl->load($xslfile->getAbsolutePath());
$proc = new XSLTProcessor();
if (defined('XSL_SECPREF_WRITE_FILE')) {
if (version_compare(PHP_VERSION, '5.4', "<")) {
ini_set("xsl.security_prefs", XSL_SECPREF_WRITE_FILE | XSL_SECPREF_CREATE_DIRECTORY);
} else {
$proc->setSecurityPrefs(XSL_SECPREF_WRITE_FILE | XSL_SECPREF_CREATE_DIRECTORY);
}
}
$proc->importStyleSheet($xsl);
ExtendedFileStream::registerStream();
$toDir = (string) $this->toDir;
// urlencode() the path if we're on Windows
if (FileSystem::getFileSystem()->getSeparator() == '\\') {
$toDir = urlencode($toDir);
}
// no output for the framed report
// it's all done by extension...
$proc->setParameter('', 'output.dir', $toDir);
$proc->setParameter('', 'output.sorttable', $this->useSortTable);
$proc->setParameter('', 'document.title', $this->title);
$proc->transformToXML($this->document);
ExtendedFileStream::unregisterStream();
}
/**
* @return PhingFile
* @throws BuildException
*/
private function getStyleSheet()
{
$xslname = "coverage-frames.xsl";
if ($this->styleDir) {
$file = new PhingFile($this->styleDir, $xslname);
} else {
$path = Phing::getResourcePath("phing/etc/$xslname");
if ($path === null) {
$path = Phing::getResourcePath("etc/$xslname");
if ($path === null) {
throw new BuildException("Could not find $xslname in resource path");
}
}
$file = new PhingFile($path);
}
if (!$file->exists()) {
throw new BuildException("Could not find file " . $file->getPath());
}
return $file;
}
}
phing-2.14.0/tasks/ext/svn/SvnCopyTask.php 0000664 0001750 0001750 00000003773 12670364674 020234 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Copies a repository from the repository url to another
*
* @version $Id: 0b4894341e10f5f3ba44a669707b7727b58383f5 $
* @package phing.tasks.ext.svn
* @since 2.3.0
*/
class SvnCopyTask extends SvnBaseTask
{
private $message = "";
/**
* Sets the message
* @param $message
*/
public function setMessage($message)
{
$this->message = $message;
}
/**
* Gets the message
*/
public function getMessage()
{
return $this->message;
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('copy');
$this->log("Copying SVN repository from '" . $this->getRepositoryUrl() . "' to '" . $this->getToDir() . "'");
$options = array();
if (strlen($this->getMessage()) > 0) {
$options['message'] = $this->getMessage();
}
$this->run(array($this->getToDir()), $options);
}
}
phing-2.14.0/tasks/ext/svn/SvnCheckoutTask.php 0000664 0001750 0001750 00000004207 12670364674 021060 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Checks out a repository to a local directory
*
* @author Andrew Eddie
* @version $Id: 34178e3af0b03b5da591c716f43bbc49a25cdcb4 $
* @package phing.tasks.ext.svn
* @since 2.3.0
*/
class SvnCheckoutTask extends SvnBaseTask
{
/**
* Which Revision to Export
*
* @todo check if version_control_svn supports constants
*
* @var string
*/
private $revision = 'HEAD';
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('checkout');
$this->log(
"Checking out SVN repository to '" . $this->getToDir(
) . "'" . ($this->revision == 'HEAD' ? '' : " (revision: {$this->revision})")
);
// revision
$switches = array(
'r' => $this->revision,
);
$this->run(array($this->getToDir()), $switches);
}
/**
* @param $revision
*/
public function setRevision($revision)
{
$this->revision = $revision;
}
}
phing-2.14.0/tasks/ext/svn/SvnLastRevisionTask.php 0000775 0001750 0001750 00000006553 12670364674 021746 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Stores the number of the last revision of a workingcopy in a property
*
* @author Michiel Rook
* @version $Id: 61bd055f46bd8430785610a76271250d2e30786e $
* @package phing.tasks.ext.svn
* @see VersionControl_SVN
* @since 2.1.0
*/
class SvnLastRevisionTask extends SvnBaseTask
{
private $propertyName = "svn.lastrevision";
private $lastChanged = false;
/**
* Sets the name of the property to use
* @param string $propertyName
*/
public function setPropertyName($propertyName)
{
$this->propertyName = $propertyName;
}
/**
* Returns the name of the property to use
* @return string
*/
public function getPropertyName()
{
return $this->propertyName;
}
/**
* Sets whether to force compatibility with older SVN versions (< 1.2)
*
* Retained for legacy reasons
* @deprecated
* @param $force
*/
public function setForceCompatible($force)
{
}
/**
* Sets whether to retrieve the last changed revision
* @param $lastChanged
*/
public function setLastChanged($lastChanged)
{
$this->lastChanged = (bool) $lastChanged;
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('info');
if ($this->oldVersion) {
$output = $this->run(array('--xml'));
if (!($xmlObj = @simplexml_load_string($output))) {
throw new BuildException("Failed to parse the output of 'svn info --xml'.");
}
if ($this->lastChanged) {
$found = (int) $xmlObj->entry->commit['revision'];
} else {
$found = (int) $xmlObj->entry['revision'];
}
} else {
$output = $this->run();
if (empty($output) || !isset($output['entry'][0])) {
throw new BuildException("Failed to parse the output of 'svn info'.");
}
if ($this->lastChanged) {
$found = $output['entry'][0]['commit']['revision'];
} else {
$found = $output['entry'][0]['revision'];
}
}
$this->project->setProperty($this->getPropertyName(), $found);
}
}
phing-2.14.0/tasks/ext/svn/SvnExportTask.php 0000775 0001750 0001750 00000004175 12670364674 020603 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Exports/checks out a repository to a local directory
* with authentication
*
* @author Michiel Rook
* @author Andrew Eddie
* @version $Id: d12b9c4d44e42e6a36e544fbb0f03c0bd64ec428 $
* @package phing.tasks.ext.svn
* @since 2.2.0
*/
class SvnExportTask extends SvnBaseTask
{
/**
* Which Revision to Export
*
* @todo check if version_control_svn supports constants
*
* @var string
*/
private $revision = 'HEAD';
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('export');
$this->log("Exporting SVN repository to '" . $this->getToDir() . "'");
$switches = array();
if (!empty($this->revision)) {
$switches['r'] = $this->revision;
}
$this->run(array($this->getToDir()), $switches);
}
/**
* @param $revision
*/
public function setRevision($revision)
{
$this->revision = $revision;
}
}
phing-2.14.0/tasks/ext/svn/SvnInfoTask.php 0000664 0001750 0001750 00000007062 12670364674 020210 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Parses the output of 'svn info --xml' and
*
* @author Michiel Rook
*
* @package phing.tasks.ext.svn
*
* @see VersionControl_SVN
* @since 2.4.9
*/
class SvnInfoTask extends SvnBaseTask
{
private $propertyName = "svn.info";
private $element = 'url';
private $subElement = null;
/**
* Sets the name of the property to use
* @param $propertyName
*/
public function setPropertyName($propertyName)
{
$this->propertyName = $propertyName;
}
/**
* Returns the name of the property to use
*/
public function getPropertyName()
{
return $this->propertyName;
}
/**
* Sets the name of the xml element to use.
*
* @param string $element
*
* @return void
*/
public function setElement($element)
{
$this->element = $element;
}
/**
* Returns the name of the xml element to use.
*
* @return string
*/
public function getElement()
{
return $this->element;
}
/**
* Sets the name of the xml sub element to use.
*
* @param $subElement
*
* @return void
*/
public function setSubElement($subElement)
{
$this->subElement = $subElement;
}
/**
* Returns the name of the xml sub element to use.
*
* @return string
*/
public function getSubElement()
{
return $this->subElement;
}
/**
* The main entry point.
*
* @return void
*
* @throws BuildException
*/
public function main()
{
$this->setup('info');
if ($this->oldVersion) {
$output = $this->run(array('--xml', '--incremental'));
if (!($xmlObj = @simplexml_load_string($output))) {
throw new BuildException("Failed to parse the output of 'svn info --xml'.");
}
$object = $xmlObj->{$this->element};
if (!empty($this->subElement)) {
$object = $object->{$this->subElement};
}
} else {
$output = $this->run();
if (empty($output) || !isset($output['entry'][0])) {
throw new BuildException("Failed to parse the output of 'svn info'.");
}
$object = $output['entry'][0][$this->element];
if (!empty($this->subElement)) {
$object = $object[$this->subElement];
}
}
$this->project->setProperty($this->getPropertyName(), (string) $object);
}
}
phing-2.14.0/tasks/ext/svn/SvnLogTask.php 0000775 0001750 0001750 00000006502 12670364674 020037 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Stores the output of a log command on a workingcopy or repositoryurl in a property.
* This stems from the SvnLastRevisionTask.
*
* @author Anton Stöckl
* @author Michiel Rook (SvnLastRevisionTask)
* @version $Id: 7e1ed209fca1c776aa105241110a78a65284f6ae $
* @package phing.tasks.ext.svn
* @see VersionControl_SVN
* @since 2.1.0
*/
class SvnLogTask extends SvnBaseTask
{
private $propertyName = "svn.log";
private $limit = null;
/**
* Sets the name of the property to use
* @param $propertyName
*/
public function setPropertyName($propertyName)
{
$this->propertyName = $propertyName;
}
/**
* Returns the name of the property to use
*/
public function getPropertyName()
{
return $this->propertyName;
}
/**
* Sets whether to force compatibility with older SVN versions (< 1.2)
* @deprecated
* @param $force
*/
public function setForceCompatible($force)
{
}
/**
* Sets the max num of log entries to get from svn
* @param $limit
*/
public function setLimit($limit)
{
$this->limit = (int) $limit;
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('log');
$switches = array();
if ($this->limit > 0) {
$switches['limit'] = $this->limit;
}
$output = $this->run(array(), $switches);
$result = null;
if ($this->oldVersion) {
foreach ($output as $line) {
$result .= (!empty($result)) ? "\n" : '';
$result .= "{$line['REVISION']} | {$line['AUTHOR']} | {$line['DATE']} | {$line['MSG']}";
}
} else {
foreach ($output['logentry'] as $line) {
$result .= (!empty($result)) ? "\n" : '';
$result .= "{$line['revision']} | {$line['author']} | {$line['date']} | {$line['msg']}";
}
}
if (!empty($result)) {
$this->project->setProperty($this->getPropertyName(), $result);
} else {
throw new BuildException("Failed to parse the output of 'svn log'.");
}
}
}
phing-2.14.0/tasks/ext/svn/SvnSwitchTask.php 0000664 0001750 0001750 00000004476 12670364674 020564 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Switches a repository at a given local directory to a different location
*
* @author Dom Udall
* @version $Id: f840cd73068d8b9cf90051b0be3101ee9f22d4fc $
* @package phing.tasks.ext.svn
* @since 2.4.3
*/
class SvnSwitchTask extends SvnBaseTask
{
/**
* Which Revision to Export
*
* @todo check if version_control_svn supports constants
*
* @var string
*/
private $revision = 'HEAD';
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('switch');
$this->log(
"Switching SVN repository at '" . $this->getToDir() . "' to '" . $this->getRepositoryUrl() . "' "
. ($this->getRevision() == 'HEAD' ? '' : " (revision: {$this->getRevision()})")
);
// revision
$switches = array(
'r' => $this->getRevision(),
);
$this->run(array($this->getToDir()), $switches);
}
/**
* @param $revision
*/
public function setRevision($revision)
{
$this->revision = $revision;
}
/**
* @return string
*/
public function getRevision()
{
return $this->revision;
}
}
phing-2.14.0/tasks/ext/svn/SvnCommitTask.php 0000664 0001750 0001750 00000006540 12670364674 020545 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Commits changes in a local working copy to the repository
*
* @author Johan Persson
* @version $Id: eec7114955b928683994705ad4dc68fe246ef23f $
* @package phing.tasks.ext.svn
* @since 2.4.0
*/
class SvnCommitTask extends SvnBaseTask
{
/**
* Commit message
*/
private $message = '';
/**
* Property name where we store the revision number of the just
* committed version.
*/
private $propertyName = "svn.committedrevision";
/**
* Sets the commit message
* @param $message
*/
public function setMessage($message)
{
$this->message = $message;
}
/**
* Gets the commit message
*/
public function getMessage()
{
return $this->message;
}
/**
* Sets the name of the property to use for returned revision
* @param $propertyName
*/
public function setPropertyName($propertyName)
{
$this->propertyName = $propertyName;
}
/**
* Returns the name of the property to use for returned revision
*/
public function getPropertyName()
{
return $this->propertyName;
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
if (trim($this->message) === '') {
throw new BuildException('SVN Commit message can not be empty.');
}
$this->setup('commit');
$this->log(
"Committing SVN working copy at '" . $this->getWorkingCopy() . "' with message '" . $this->GetMessage() . "'"
);
$output = $this->run(array(), array('message' => $this->GetMessage()));
if (preg_match('/[\s]*Committed revision[\s]+([\d]+)/', $output, $matches)) {
$this->project->setProperty($this->getPropertyName(), $matches[1]);
} else {
/**
* If no new revision was committed set revision to "empty". Remember that
* this is not necessarily an error. It could be that the specified working
* copy is identical to the copy in the repository and in that case
* there will be no update and no new revision number.
*/
$this->project->setProperty($this->getPropertyName(), '');
}
}
}
phing-2.14.0/tasks/ext/svn/SvnUpdateTask.php 0000664 0001750 0001750 00000004172 12670364674 020536 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Updates a repository in local directory
*
* @author Andrew Eddie
* @version $Id: e29c24db4d10667a89d1829fe80075fbf8e3292c $
* @package phing.tasks.ext.svn
* @since 2.3.0
*/
class SvnUpdateTask extends SvnBaseTask
{
/**
* Which Revision to Export
*
* @todo check if version_control_svn supports constants
*
* @var string
*/
private $revision = 'HEAD';
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('update');
$this->log(
"Updating SVN repository at '" . $this->getToDir(
) . "'" . ($this->revision == 'HEAD' ? '' : " (revision: {$this->revision})")
);
// revision
$switches = array(
'r' => $this->revision,
);
$this->run(array($this->getToDir()), $switches);
}
/**
* @param $revision
*/
public function setRevision($revision)
{
$this->revision = $revision;
}
}
phing-2.14.0/tasks/ext/svn/SvnListTask.php 0000775 0001750 0001750 00000010544 12670364674 020232 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/svn/SvnBaseTask.php';
/**
* Stores the output of a list command on a workingcopy or repositoryurl in a property.
* This stems from the SvnLastRevisionTask.
*
* @author Anton Stöckl
* @author Michiel Rook (SvnLastRevisionTask)
* @version $Id: bb6bda1d445fc14e863a2c88b2d11acaebe757c0 $
* @package phing.tasks.ext.svn
* @see VersionControl_SVN
* @since 2.1.0
*/
class SvnListTask extends SvnBaseTask
{
private $propertyName = "svn.list";
private $limit = null;
private $orderDescending = false;
/**
* Sets the name of the property to use
* @param $propertyName
*/
public function setPropertyName($propertyName)
{
$this->propertyName = $propertyName;
}
/**
* Returns the name of the property to use
*/
public function getPropertyName()
{
return $this->propertyName;
}
/**
* Sets whether to force compatibility with older SVN versions (< 1.2)
* @deprecated
* @param $force
*/
public function setForceCompatible($force)
{
}
/**
* Sets the max num of tags to display
* @param $limit
*/
public function setLimit($limit)
{
$this->limit = (int) $limit;
}
/**
* Sets whether to sort tags in descending order
* @param $orderDescending
*/
public function setOrderDescending($orderDescending)
{
$this->orderDescending = (bool) $orderDescending;
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$this->setup('list');
if ($this->oldVersion) {
$this->svn->setOptions(array('fetchmode' => VERSIONCONTROL_SVN_FETCHMODE_XML));
$output = $this->run(array('--xml'));
if (!($xmlObj = @simplexml_load_string($output))) {
throw new BuildException("Failed to parse the output of 'svn list --xml'.");
}
$objects = $xmlObj->list->entry;
$entries = array();
foreach ($objects as $object) {
$entries[] = array(
'commit' => array(
'revision' => (string) $object->commit['revision'],
'author' => (string) $object->commit->author,
'date' => (string) $object->commit->date
),
'name' => (string) $object->name
);
}
} else {
$output = $this->run(array());
$entries = $output['list'][0]['entry'];
}
if ($this->orderDescending) {
$entries = array_reverse($entries);
}
$result = null;
$count = 0;
foreach ($entries as $entry) {
if ($this->limit > 0 && $count >= $this->limit) {
break;
}
$result .= (!empty($result)) ? "\n" : '';
$result .= $entry['commit']['revision'] . ' | ' . $entry['commit']['author'] . ' | ' . $entry['commit']['date'] . ' | ' . $entry['name'];
$count++;
}
if (!empty($result)) {
$this->project->setProperty($this->getPropertyName(), $result);
} else {
throw new BuildException("Failed to parse the output of 'svn list'.");
}
}
}
phing-2.14.0/tasks/ext/svn/SvnBaseTask.php 0000775 0001750 0001750 00000022752 12670364674 020175 0 ustar michiel michiel .
*/
include_once 'phing/Task.php';
/**
* Base class for Subversion tasks
*
* @author Michiel Rook
* @author Andrew Eddie
*
* @package phing.tasks.ext.svn
*
* @see VersionControl_SVN
* @since 2.2.0
*/
abstract class SvnBaseTask extends Task
{
/**
* @var string
*/
private $workingCopy = "";
/**
* @var string
*/
private $repositoryUrl = "";
/**
* @var string
*/
private $svnPath = "/usr/bin/svn";
protected $svn = null;
private $mode = "";
private $svnArgs = array();
private $svnSwitches = array();
private $toDir = "";
protected $fetchMode;
protected $oldVersion = false;
/**
* Initialize Task.
* This method includes any necessary SVN libraries and triggers
* appropriate error if they cannot be found. This is not done in header
* because we may want this class to be loaded w/o triggering an error.
*/
public function init()
{
include_once 'VersionControl/SVN.php';
$this->fetchMode = VERSIONCONTROL_SVN_FETCHMODE_ASSOC;
if (!class_exists('VersionControl_SVN')) {
throw new Exception("The SVN tasks depend on PEAR VersionControl_SVN package being installed.");
}
}
/**
* Sets the path to the workingcopy
* @param $workingCopy
*/
public function setWorkingCopy($workingCopy)
{
$this->workingCopy = $workingCopy;
}
/**
* Returns the path to the workingcopy
*/
public function getWorkingCopy()
{
return $this->workingCopy;
}
/**
* Sets the path/URI to the repository
* @param $repositoryUrl
*/
public function setRepositoryUrl($repositoryUrl)
{
$this->repositoryUrl = $repositoryUrl;
}
/**
* Returns the path/URI to the repository
*/
public function getRepositoryUrl()
{
return $this->repositoryUrl;
}
/**
* Sets the path to the SVN executable
* @param $svnPath
*/
public function setSvnPath($svnPath)
{
$this->svnPath = $svnPath;
}
/**
* Returns the path to the SVN executable
*/
public function getSvnPath()
{
return $this->svnPath;
}
//
// Args
//
/**
* Sets the path to export/checkout to
* @param $toDir
*/
public function setToDir($toDir)
{
$this->toDir = $toDir;
}
/**
* Returns the path to export/checkout to
*/
public function getToDir()
{
return $this->toDir;
}
//
// Switches
//
/**
* Sets the force switch
* @param $value
*/
public function setForce($value)
{
$this->svnSwitches['force'] = $value;
}
/**
* Returns the force switch
*/
public function getForce()
{
return isset($this->svnSwitches['force']) ? $this->svnSwitches['force'] : '';
}
/**
* Sets the username of the user to export
* @param $value
*/
public function setUsername($value)
{
$this->svnSwitches['username'] = $value;
}
/**
* Returns the username
*/
public function getUsername()
{
return isset($this->svnSwitches['username']) ? $this->svnSwitches['username'] : '';
}
/**
* Sets the password of the user to export
* @param $value
*/
public function setPassword($value)
{
$this->svnSwitches['password'] = $value;
}
/**
* Returns the password
*/
public function getPassword()
{
return isset($this->svnSwitches['password']) ? $this->svnSwitches['password'] : '';
}
/**
* Sets the no-auth-cache switch
* @param $value
*/
public function setNoCache($value)
{
$this->svnSwitches['no-auth-cache'] = $value;
}
/**
* Returns the no-auth-cache switch
*/
public function getNoCache()
{
return isset($this->svnSwitches['no-auth-cache']) ? $this->svnSwitches['no-auth-cache'] : '';
}
/**
* Sets the recursive switch
* @deprecated
* @param $value
*/
public function setRecursive($value)
{
}
/**
* Returns the recursive switch
* @deprecated
*/
public function getRecursive()
{
}
/**
* Sets the depth switch
* @param $value
*/
public function setDepth($value)
{
$this->svnSwitches['depth'] = $value;
}
/**
* Returns the depth switch
*/
public function getDepth()
{
return isset($this->svnSwitches['depth']) ? $this->svnSwitches['depth'] : '';
}
/**
* Sets the ignore-externals switch
* @param $value
*/
public function setIgnoreExternals($value)
{
$this->svnSwitches['ignore-externals'] = $value;
}
/**
* Returns the ignore-externals switch
*/
public function getIgnoreExternals()
{
return isset($this->svnSwitches['ignore-externals']) ? $this->svnSwitches['ignore-externals'] : '';
}
/**
* Sets the trust-server-cert switch
* @param $value
*/
public function setTrustServerCert($value)
{
$this->svnSwitches['trust-server-cert'] = $value;
}
/**
* Returns the trust-server-cert switch
*/
public function getTrustServerCert()
{
return isset($this->svnSwitches['trust-server-cert']) ? $this->svnSwitches['trust-server-cert'] : '';
}
/**
* Creates a VersionControl_SVN class based on $mode
*
* @param string The SVN mode to use (info, export, checkout, ...)
* @throws BuildException
*/
protected function setup($mode)
{
$this->mode = $mode;
// Set up runtime options. Will be passed to all
// subclasses.
$options = array('fetchmode' => $this->fetchMode);
if ($this->oldVersion) {
$options['svn_path'] = $this->getSvnPath();
} else {
$options['binaryPath'] = $this->getSvnPath();
}
// Pass array of subcommands we need to factory
$this->svn = VersionControl_SVN::factory($mode, $options);
if (get_parent_class($this->svn) !== 'VersionControl_SVN_Command') {
$this->oldVersion = true;
$this->svn->use_escapeshellcmd = false;
}
if (!empty($this->repositoryUrl)) {
$this->svnArgs = array($this->repositoryUrl);
} else {
if (!empty($this->workingCopy)) {
if (is_dir($this->workingCopy)) {
$this->svnArgs = array($this->workingCopy);
} else {
if ($mode == 'info') {
if (is_file($this->workingCopy)) {
$this->svnArgs = array($this->workingCopy);
} else {
throw new BuildException("'" . $this->workingCopy . "' is not a directory nor a file");
}
} else {
throw new BuildException("'" . $this->workingCopy . "' is not a directory");
}
}
}
}
}
/**
* Executes the constructed VersionControl_SVN instance
*
* @param array $args
* @param array $switches
* @throws BuildException
* @internal param Additional $array arguments to pass to SVN.
* @internal param Switches $array to pass to SVN.
* @return string Output generated by SVN.
*/
protected function run($args = array(), $switches = array())
{
$tempArgs = array_merge($this->svnArgs, $args);
$tempSwitches = array_merge($this->svnSwitches, $switches);
if ($this->oldVersion) {
$svnstack = PEAR_ErrorStack::singleton('VersionControl_SVN');
if ($output = $this->svn->run($tempArgs, $tempSwitches)) {
return $output;
}
if (count($errs = $svnstack->getErrors())) {
$err = current($errs);
$errorMessage = $err['message'];
if (isset($err['params']['errstr'])) {
$errorMessage = $err['params']['errstr'];
}
throw new BuildException("Failed to run the 'svn " . $this->mode . "' command: " . $errorMessage);
}
} else {
try {
return $this->svn->run($tempArgs, $tempSwitches);
} catch (Exception $e) {
throw new BuildException("Failed to run the 'svn " . $this->mode . "' command: " . $e->getMessage());
}
}
}
}
phing-2.14.0/tasks/ext/SymlinkTask.php 0000664 0001750 0001750 00000016255 12670364674 017452 0 ustar michiel michiel .
*/
require_once "phing/Task.php";
/**
* Generates symlinks based on a target / link combination.
* Can also symlink contents of a directory, individually
*
* Single target symlink example:
*
*
*
*
* Symlink entire contents of directory
*
* This will go through the contents of "/my/shared/library/*"
* and create a symlink for each entry into ${project.basedir}/library/
*
*
*
*
*
*
*
*
* @author Andrei Serdeliuc
* @extends Task
* @version $ID$
* @package phing.tasks.ext
*/
class SymlinkTask extends Task
{
/**
* What we're symlinking from
*
* (default value: null)
*
* @var string
*/
private $_target = null;
/**
* Symlink location
*
* (default value: null)
*
* @var string
*/
private $_link = null;
/**
* Collection of filesets
* Used when linking contents of a directory
*
* (default value: array())
*
* @var array
*/
private $_filesets = array();
/**
* Whether to override the symlink if it exists but points
* to a different location
*
* (default value: false)
*
* @var boolean
*/
private $_overwrite = false;
/**
* setter for _target
*
* @param string $target
* @return void
*/
public function setTarget($target)
{
$this->_target = $target;
}
/**
* setter for _link
*
* @param string $link
* @return void
*/
public function setLink($link)
{
$this->_link = $link;
}
/**
* creator for _filesets
*
* @return FileSet
*/
public function createFileset()
{
$num = array_push($this->_filesets, new FileSet());
return $this->_filesets[$num - 1];
}
/**
* setter for _overwrite
*
* @param boolean $overwrite
* @return void
*/
public function setOverwrite($overwrite)
{
$this->_overwrite = $overwrite;
}
/**
* getter for _target
*
* @throws BuildException
* @return string
*/
public function getTarget()
{
if ($this->_target === null) {
throw new BuildException('Target not set');
}
return $this->_target;
}
/**
* getter for _link
*
* @throws BuildException
* @return string
*/
public function getLink()
{
if ($this->_link === null) {
throw new BuildException('Link not set');
}
return $this->_link;
}
/**
* getter for _filesets
*
* @return array
*/
public function getFilesets()
{
return $this->_filesets;
}
/**
* getter for _overwrite
*
* @return boolean
*/
public function getOverwrite()
{
return $this->_overwrite;
}
/**
* Generates an array of directories / files to be linked
* If _filesets is empty, returns getTarget()
*
* @throws BuildException
* @return array|string
*/
protected function getMap()
{
$fileSets = $this->getFilesets();
// No filesets set
// We're assuming single file / directory
if (empty($fileSets)) {
return $this->getTarget();
}
$targets = array();
foreach ($fileSets as $fs) {
if (!($fs instanceof FileSet)) {
continue;
}
// We need a directory to store the links
if (!is_dir($this->getLink())) {
throw new BuildException('Link must be an existing directory when using fileset');
}
$fromDir = $fs->getDir($this->getProject())->getAbsolutePath();
if (!is_dir($fromDir)) {
$this->log('Directory doesn\'t exist: ' . $fromDir, Project::MSG_WARN);
continue;
}
$fsTargets = array();
$ds = $fs->getDirectoryScanner($this->getProject());
$fsTargets = array_merge(
$fsTargets,
$ds->getIncludedDirectories(),
$ds->getIncludedFiles()
);
// Add each target to the map
foreach ($fsTargets as $target) {
if (!empty($target)) {
$targets[$target] = $fromDir . DIRECTORY_SEPARATOR . $target;
}
}
}
return $targets;
}
/**
* Main entry point for task
*
* @return bool
*/
public function main()
{
$map = $this->getMap();
// Single file symlink
if (is_string($map)) {
return $this->symlink($map, $this->getLink());
}
// Multiple symlinks
foreach ($map as $name => $targetPath) {
$this->symlink($targetPath, $this->getLink() . DIRECTORY_SEPARATOR . $name);
}
return true;
}
/**
* Create the actual link
*
* @param string $target
* @param string $link
* @return bool
*/
protected function symlink($target, $link)
{
$fs = FileSystem::getFileSystem();
if (is_link($link) && @readlink($link) == $target) {
$this->log('Link exists: ' . $link, Project::MSG_INFO);
return true;
}
if (file_exists($link) || is_link($link)) {
if (!$this->getOverwrite()) {
$this->log('Not overwriting existing link ' . $link, Project::MSG_ERR);
return false;
}
if (is_link($link) || is_file($link)) {
$fs->unlink($link);
$this->log('Link removed: ' . $link, Project::MSG_INFO);
} else {
$fs->rmdir($link, true);
$this->log('Directory removed: ' . $link, Project::MSG_INFO);
}
}
$this->log('Linking: ' . $target . ' to ' . $link, Project::MSG_INFO);
return $fs->symlink($target, $link);
}
}
phing-2.14.0/tasks/ext/ioncube/IoncubeComment.php 0000775 0001750 0001750 00000002750 12670364674 021532 0 ustar michiel michiel .
*/
/**
* Wrapper for comments for ionCube tasks
*
* @author Michiel Rook
* @version $Id: a07beee075383ef21856e1931b9867085b033b67 $
* @package phing.tasks.ext.ioncube
* @since 2.2.0
*/
class IoncubeComment
{
private $value = "";
/**
* @return string
*/
public function getValue()
{
return $this->value;
}
/**
* @param $txt
*/
public function addText($txt)
{
$this->value = trim($txt);
}
}
phing-2.14.0/tasks/ext/ioncube/IoncubeLicenseTask.php 0000775 0001750 0001750 00000012376 12670364674 022342 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/ioncube/IoncubeComment.php';
/**
* Invokes the ionCube "make_license" program
*
* @author Michiel Rook
* @version $Id: 46bbb0c463665f3960cef69b836652c4f3f4c32c $
* @package phing.tasks.ext.ioncube
* @since 2.2.0
*/
class IoncubeLicenseTask extends Task
{
private $ioncubePath = "/usr/local/ioncube";
private $licensePath = "";
private $passPhrase = "";
private $allowedServer = "";
private $expireOn = "";
private $expireIn = "";
private $comments = array();
/**
* Sets the path to the ionCube encoder
* @param $ioncubePath
*/
public function setIoncubePath($ioncubePath)
{
$this->ioncubePath = $ioncubePath;
}
/**
* Returns the path to the ionCube encoder
*/
public function getIoncubePath()
{
return $this->ioncubePath;
}
/**
* Sets the path to the license file to use
* @param $licensePath
*/
public function setLicensePath($licensePath)
{
$this->licensePath = $licensePath;
}
/**
* Returns the path to the license file to use
*/
public function getLicensePath()
{
return $this->licensePath;
}
/**
* Sets the passphrase to use when encoding files
* @param $passPhrase
*/
public function setPassPhrase($passPhrase)
{
$this->passPhrase = $passPhrase;
}
/**
* Returns the passphrase to use when encoding files
*/
public function getPassPhrase()
{
return $this->passPhrase;
}
/**
* Adds a comment to be used in encoded files
* @param IoncubeComment $comment
*/
public function addComment(IoncubeComment $comment)
{
$this->comments[] = $comment;
}
/**
* Sets the --allowed-server option to use when generating the license
* @param $allowedServer
*/
public function setAllowedServer($allowedServer)
{
$this->allowedServer = $allowedServer;
}
/**
* Returns the --allowed-server option
*/
public function getAllowedServer()
{
return $this->allowedServer;
}
/**
* Sets the --expire-on option to use when generating the license
* @param $expireOn
*/
public function setExpireOn($expireOn)
{
$this->expireOn = $expireOn;
}
/**
* Returns the --expire-on option
*/
public function getExpireOn()
{
return $this->expireOn;
}
/**
* Sets the --expire-in option to use when generating the license
* @param $expireIn
*/
public function setExpireIn($expireIn)
{
$this->expireIn = $expireIn;
}
/**
* Returns the --expire-in option
*/
public function getExpireIn()
{
return $this->expireIn;
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$arguments = $this->constructArguments();
$makelicense = new PhingFile($this->ioncubePath, 'make_license');
$this->log("Running ionCube make_license...");
exec($makelicense->__toString() . " " . $arguments . " 2>&1", $output, $return);
if ($return != 0) {
throw new BuildException("Could not execute ionCube make_license: " . implode(' ', $output));
}
}
/**
* Constructs an argument string for the ionCube make_license
*/
private function constructArguments()
{
$arguments = "";
if (!empty($this->passPhrase)) {
$arguments .= "--passphrase '" . $this->passPhrase . "' ";
}
foreach ($this->comments as $comment) {
$arguments .= "--header-line '" . $comment->getValue() . "' ";
}
if (!empty($this->licensePath)) {
$arguments .= "--o '" . $this->licensePath . "' ";
}
if (!empty($this->allowedServer)) {
$arguments .= "--allowed-server {" . $this->allowedServer . "} ";
}
if (!empty($this->expireOn)) {
$arguments .= "--expire-on " . $this->expireOn . " ";
}
if (!empty($this->expireIn)) {
$arguments .= "--expire-in " . $this->expireIn . " ";
}
return $arguments;
}
}
phing-2.14.0/tasks/ext/ioncube/IoncubeEncoderTask.php 0000775 0001750 0001750 00000036232 12670364674 022334 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/ioncube/IoncubeComment.php';
/**
* Invokes the ionCube Encoder (PHP4 or PHP5)
*
* @author Michiel Rook
* @author Andrew Eddie
* @author Domenico Sgarbossa
* @version $Id: 03f95f42b0965ac16a78438fbc7e77c9eaf89e9c $
* @package phing.tasks.ext.ioncube
* @since 2.2.0
*/
class IoncubeEncoderTask extends Task
{
private $ionSwitches = array();
private $ionOptions = array();
private $ionOptionsXS = array();
private $comments = array();
private $encoderName = 'ioncube_encoder';
private $fromDir = '';
private $ioncubePath = '/usr/local/ioncube';
private $phpVersion = '5';
private $targetOption = '';
private $toDir = '';
private $showCommandLine = false;
/**
* Sets whether to show command line before it is executed
* @param $value
*/
public function setShowCommandLine($value)
{
$this->showCommandLine = $value;
}
/**
* Adds a comment to be used in encoded files
* @param IoncubeComment $comment
*/
public function addComment(IoncubeComment $comment)
{
$this->comments[] = $comment;
}
/**
* Sets the allowed server
* @param $value
*/
public function setAllowedServer($value)
{
$this->ionOptionsXS['allowed-server'] = $value;
}
/**
* Returns the allowed server setting
*/
public function getAllowedServer()
{
return $this->ionOptionsXS['allowed-server'];
}
/**
* Sets the binary option
* @param $value
*/
public function setBinary($value)
{
$this->ionSwitches['binary'] = $value;
}
/**
* Returns the binary option
*/
public function getBinary()
{
return $this->ionSwitches['binary'];
}
/**
* Sets files or folders to copy (separated by space)
* @param $value
*/
public function setCopy($value)
{
$this->ionOptionsXS['copy'] = $value;
}
/**
* Returns the copy setting
*/
public function getCopy()
{
return $this->ionOptionsXS['copy'];
}
/**
* Sets additional file patterns, files or directories to encode,
* or to reverse the effect of copy (separated by space)
* @param $value
*/
public function setEncode($value)
{
$this->ionOptionsXS['encode'] = $value;
}
/**
* Returns the encode setting
*/
public function getEncode()
{
return $this->ionOptionsXS['encode'];
}
/**
* Sets regexps of additional files to encrypt (separated by space)
* @param $value
*/
public function setEncrypt($value)
{
$this->ionOptionsXS['encrypt'] = $value;
}
/**
* Returns regexps of additional files to encrypt (separated by space)
*/
public function getEncrypt()
{
return $this->ionOptionsXS['encrypt'];
}
/**
* Sets a period after which the files expire
* @param $value
*/
public function setExpirein($value)
{
$this->ionOptions['expire-in'] = $value;
}
/**
* Returns the expireIn setting
*/
public function getExpirein()
{
return $this->ionOptions['expire-in'];
}
/**
* Sets a YYYY-MM-DD date to expire the files
* @param $value
*/
public function setExpireon($value)
{
$this->ionOptions['expire-on'] = $value;
}
/**
* Returns the expireOn setting
*/
public function getExpireon()
{
return $this->ionOptions['expire-on'];
}
/**
* Sets the source directory
* @param $value
*/
public function setFromDir($value)
{
$this->fromDir = $value;
}
/**
* Returns the source directory
*/
public function getFromDir()
{
return $this->fromDir;
}
/**
* Set files and directories to ignore entirely and exclude from the target directory
* (separated by space).
* @param $value
*/
public function setIgnore($value)
{
$this->ionOptionsXS['ignore'] = $value;
}
/**
* Returns the ignore setting
*/
public function getIgnore()
{
return $this->ionOptionsXS['ignore'];
}
/**
* Sets the path to the ionCube encoder
* @param $value
*/
public function setIoncubePath($value)
{
$this->ioncubePath = $value;
}
/**
* Returns the path to the ionCube encoder
*/
public function getIoncubePath()
{
return $this->ioncubePath;
}
/**
* Set files and directories not to be ignored (separated by space).
* @param $value
*/
public function setKeep($value)
{
$this->ionOptionsXS['keep'] = $value;
}
/**
* Returns the ignore setting
*/
public function getKeep()
{
return $this->ionOptionsXS['keep'];
}
/**
* Sets the path to the license file to use
* @param $value
*/
public function setLicensePath($value)
{
$this->ionOptions['with-license'] = $value;
}
/**
* Returns the path to the license file to use
*/
public function getLicensePath()
{
return $this->ionOptions['with-license'];
}
/**
* Sets the no-doc-comments option
* @param $value
*/
public function setNoDocComments($value)
{
$this->ionSwitches['no-doc-comment'] = $value;
}
/**
* Returns the no-doc-comments option
*/
public function getNoDocComments()
{
return $this->ionSwitches['no-doc-comment'];
}
/**
* Sets the obfuscate option
* @param $value
*/
public function setObfuscate($value)
{
$this->ionOptionsXS['obfuscate'] = $value;
}
/**
* Returns the optimize option
*/
public function getObfuscate()
{
return $this->ionOptionsXS['obfuscate'];
}
/**
* Sets the obfuscation key (required if using the obfuscate option)
* @param $value
*/
public function setObfuscationKey($value)
{
$this->ionOptions['obfuscation-key'] = $value;
}
/**
* Returns the optimize option
*/
public function getObfuscationKey()
{
return $this->ionOptions['obfuscation-key'];
}
/**
* Sets the optimize option
* @param $value
*/
public function setOptimize($value)
{
$this->ionOptions['optimize'] = $value;
}
/**
* Returns the optimize option
*/
public function getOptimize()
{
return $this->ionOptions['optimize'];
}
/**
* Sets the passphrase to use when encoding files
* @param $value
*/
public function setPassPhrase($value)
{
$this->ionOptions['passphrase'] = $value;
}
/**
* Returns the passphrase to use when encoding files
*/
public function getPassPhrase()
{
return $this->ionOptions['passphrase'];
}
/**
* Sets the version of PHP to use (defaults to 5)
* @param $value
*/
public function setPhpVersion($value)
{
$this->phpVersion = $value;
}
/**
* Returns the version of PHP to use (defaults to 5)
*/
public function getPhpVersion()
{
return $this->phpVersion;
}
/**
* Sets the target directory
* @param $value
*/
public function setToDir($value)
{
$this->toDir = $value;
}
/**
* Returns the target directory
*/
public function getToDir()
{
return $this->toDir;
}
/**
* Sets the without-runtime-loader-support option
* @param $value
*/
public function setWithoutRuntimeLoaderSupport($value)
{
$this->ionSwitches['without-runtime-loader-support'] = $value;
}
/**
* Returns the without-runtime-loader-support option
*/
public function getWithoutRuntimeLoaderSupport()
{
return $this->ionSwitches['without-runtime-loader-support'];
}
/**
* Sets the no-short-open-tags option
* @param $value
*/
public function setNoShortOpenTags($value)
{
$this->ionSwitches['no-short-open-tags'] = $value;
}
/**
* Returns the no-short-open-tags option
*/
public function getNoShortOpenTags()
{
return $this->ionSwitches['no-short-open-tags'];
}
/**
* Sets the ignore-deprecated-warnings option
* @param $value
*/
public function setIgnoreDeprecatedWarnings($value)
{
$this->ionSwitches['ignore-deprecated-warnings'] = $value;
}
/**
* Returns the ignore-deprecated-warnings option
*/
public function getIgnoreDeprecatedWarnings()
{
return $this->ionSwitches['ignore-deprecated-warnings'];
}
/**
* Sets the ignore-strict-warnings option
* @param $value
*/
public function setIgnoreStrictWarnings($value)
{
$this->ionSwitches['ignore-strict-warnings'] = $value;
}
/**
* Returns the ignore-strict-warnings option
*/
public function getIgnoreStrictWarnings()
{
return $this->ionSwitches['ignore-strict-warnings'];
}
/**
* Sets the allow-encoding-into-source option
* @param $value
*/
public function setAllowEncodingIntoSource($value)
{
$this->ionSwitches['allow-encoding-into-source'] = $value;
}
/**
* Returns the allow-encoding-into-source option
*/
public function getAllowEncodingIntoSource()
{
return $this->ionSwitches['allow-encoding-into-source'];
}
/**
* Sets the message-if-no-loader option
* @param $value
*/
public function setMessageIfNoLoader($value)
{
$this->ionOptions['message-if-no-loader'] = $value;
}
/**
* Returns the message-if-no-loader option
*/
public function getMessageIfNoLoader()
{
return $this->ionOptions['message-if-no-loader'];
}
/**
* Sets the action-if-no-loader option
* @param $value
*/
public function setActionIfNoLoader($value)
{
$this->ionOptions['action-if-no-loader'] = $value;
}
/**
* Returns the action-if-no-loader option
*/
public function getActionIfNoLoader()
{
return $this->ionOptions['action-if-no-loader'];
}
/**
* Sets the option to use when encoding target directory already exists (defaults to none)
* @param $targetOption
*/
public function setTargetOption($targetOption)
{
$this->targetOption = $targetOption;
}
/**
* Returns the option to use when encoding target directory already exists (defaults to none)
*/
public function getTargetOption()
{
return $this->targetOption;
}
/**
* Sets the callback-file option
* @param $value
*/
public function setCallbackFile($value)
{
$this->ionOptions['callback-file'] = $value;
}
/**
* Returns the callback-file option
*/
public function getCallbackFile()
{
return $this->ionOptions['callback-file'];
}
/**
* Sets the obfuscation-exclusions-file option
* @param $value
*/
public function setObfuscationExclusionFile($value)
{
$this->ionOptions['obfuscation-exclusion-file'] = $value;
}
/**
* Returns the obfuscation-exclusions-file option
*/
public function getObfuscationExclusionFile()
{
return $this->ionOptions['obfuscation-exclusion-file'];
}
/**
* The main entry point
*
* @throws BuildException
*/
public function main()
{
$arguments = $this->constructArguments();
if (in_array($this->phpVersion, array(5, 53, 54, 55, 56))) {
$encoderName = $this->encoderName . $this->phpVersion;
} else {
$encoderName = $this->encoderName;
}
$encoder = new PhingFile($this->ioncubePath, $encoderName);
$this->log("Running ionCube Encoder...");
if ($this->showCommandLine) {
$this->log("Command line: " . $encoder->__toString() . ' ' . $arguments);
}
exec($encoder->__toString() . ' ' . $arguments . " 2>&1", $output, $return);
if ($return != 0) {
throw new BuildException("Could not execute ionCube Encoder: " . implode(' ', $output));
}
}
/**
* Constructs an argument string for the ionCube encoder
*/
private function constructArguments()
{
$arguments = '';
foreach ($this->ionSwitches as $name => $value) {
if ($value) {
$arguments .= "--$name ";
}
}
foreach ($this->ionOptions as $name => $value) {
/**
* action-if-no-loader value is a php source snippet so it is
* better to handle it this way to prevent quote problems!
*/
if ($name == 'action-if-no-loader') {
$arguments .= "--$name \"$value\" ";
} else {
$arguments .= "--$name '$value' ";
}
}
foreach ($this->ionOptionsXS as $name => $value) {
foreach (explode(' ', $value) as $arg) {
$arguments .= "--$name '$arg' ";
}
}
foreach ($this->comments as $comment) {
$arguments .= "--add-comment '" . $comment->getValue() . "' ";
}
if (!empty($this->targetOption)) {
switch ($this->targetOption) {
case "replace":
case "merge":
case "update":
case "rename":
{
$arguments .= "--" . $this->targetOption . "-target ";
}
break;
default:
{
throw new BuildException("Unknown target option '" . $this->targetOption . "'");
}
break;
}
}
if ($this->fromDir != '') {
$arguments .= $this->fromDir . ' ';
}
if ($this->toDir != '') {
$arguments .= "-o " . $this->toDir . ' ';
}
return $arguments;
}
}
phing-2.14.0/tasks/ext/FtpDeployTask.php 0000664 0001750 0001750 00000035150 12670364674 017725 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* FtpDeployTask
*
* Deploys a set of files to a remote FTP server.
*
*
* Example usage:
*
*
*
*
*
*
*
*
*
*
*
* @author Jorrit Schippers
* @contributor Steffen Sørensen
* @version $Id: 2e99e9d604f7d72f784cd742100df6d09486c102 $
* @since 2.3.1
* @package phing.tasks.ext
*/
class FtpDeployTask extends Task
{
private $host = null;
private $port = 21;
private $ssl = false;
private $username = null;
private $password = null;
private $dir = null;
private $filesets;
private $completeDirMap;
private $mode = FTP_BINARY;
private $clearFirst = false;
private $passive = false;
private $depends = false;
private $dirmode = false;
private $filemode = false;
private $rawDataFallback = false;
private $skipOnSameSize = false;
protected $logLevel = Project::MSG_VERBOSE;
/**
*
*/
public function __construct()
{
$this->filesets = array();
$this->completeDirMap = array();
}
/**
* @param $host
*/
public function setHost($host)
{
$this->host = $host;
}
/**
* @param $port
*/
public function setPort($port)
{
$this->port = (int) $port;
}
/**
* @param $ssl
*/
public function setSsl($ssl)
{
$this->ssl = (bool) $ssl;
}
/**
* @param $username
*/
public function setUsername($username)
{
$this->username = $username;
}
/**
* @param $password
*/
public function setPassword($password)
{
$this->password = $password;
}
/**
* @param $dir
*/
public function setDir($dir)
{
$this->dir = $dir;
}
/**
* @param $mode
*/
public function setMode($mode)
{
switch (strtolower($mode)) {
case 'ascii':
$this->mode = FTP_ASCII;
break;
case 'binary':
case 'bin':
$this->mode = FTP_BINARY;
break;
}
}
/**
* @param $passive
*/
public function setPassive($passive)
{
$this->passive = (bool) $passive;
}
/**
* @param $clearFirst
*/
public function setClearFirst($clearFirst)
{
$this->clearFirst = (bool) $clearFirst;
}
/**
* @param $depends
*/
public function setDepends($depends)
{
$this->depends = (bool) $depends;
}
/**
* @param $filemode
*/
public function setFilemode($filemode)
{
$this->filemode = octdec(str_pad($filemode, 4, '0', STR_PAD_LEFT));
}
/**
* @param $dirmode
*/
public function setDirmode($dirmode)
{
$this->dirmode = octdec(str_pad($dirmode, 4, '0', STR_PAD_LEFT));
}
/**
* @param $fallback
*/
public function setRawdatafallback($fallback)
{
$this->rawDataFallback = (bool) $fallback;
}
/**
* @param bool|string|int $skipOnSameSize
*/
public function setSkipOnSameSize($skipOnSameSize)
{
$this->skipOnSameSize = StringHelper::booleanValue($skipOnSameSize);
}
/**
* Nested adder, adds a set of files (nested fileset attribute).
*
* @param FileSet $fs
* @return void
*/
public function addFileSet(FileSet $fs)
{
$this->filesets[] = $fs;
}
/**
* Set level of log messages generated (default = info)
* @param string $level
*/
public function setLevel($level)
{
switch ($level) {
case "error":
$this->logLevel = Project::MSG_ERR;
break;
case "warning":
$this->logLevel = Project::MSG_WARN;
break;
case "info":
$this->logLevel = Project::MSG_INFO;
break;
case "verbose":
$this->logLevel = Project::MSG_VERBOSE;
break;
case "debug":
$this->logLevel = Project::MSG_DEBUG;
break;
}
}
/**
* The init method: check if Net_FTP is available
*/
public function init()
{
require_once 'PEAR.php';
$paths = Phing::explodeIncludePath();
foreach ($paths as $path) {
if (file_exists($path . DIRECTORY_SEPARATOR . 'Net' . DIRECTORY_SEPARATOR . 'FTP.php')) {
return true;
}
}
throw new BuildException('The FTP Deploy task requires the Net_FTP PEAR package.');
}
/**
* The main entry point method.
*/
public function main()
{
$project = $this->getProject();
require_once 'Net/FTP.php';
$ftp = new Net_FTP($this->host, $this->port);
if ($this->ssl) {
$ret = $ftp->setSsl();
if (@PEAR::isError($ret)) {
throw new BuildException('SSL connection not supported by php' . ': ' . $ret->getMessage(
));
} else {
$this->log('Use SSL connection', $this->logLevel);
}
}
$ret = $ftp->connect();
if (@PEAR::isError($ret)) {
throw new BuildException('Could not connect to FTP server ' . $this->host . ' on port ' . $this->port . ': ' . $ret->getMessage(
));
} else {
$this->log('Connected to FTP server ' . $this->host . ' on port ' . $this->port, $this->logLevel);
}
$ret = $ftp->login($this->username, $this->password);
if (@PEAR::isError($ret)) {
throw new BuildException('Could not login to FTP server ' . $this->host . ' on port ' . $this->port . ' with username ' . $this->username . ': ' . $ret->getMessage(
));
} else {
$this->log('Logged in to FTP server with username ' . $this->username, $this->logLevel);
}
if ($this->passive) {
$this->log('Setting passive mode', $this->logLevel);
$ret = $ftp->setPassive();
if (@PEAR::isError($ret)) {
$ftp->disconnect();
throw new BuildException('Could not set PASSIVE mode: ' . $ret->getMessage());
}
}
// append '/' to the end if necessary
$dir = substr($this->dir, -1) == '/' ? $this->dir : $this->dir . '/';
if ($this->clearFirst) {
// TODO change to a loop through all files and directories within current directory
$this->log('Clearing directory ' . $dir, $this->logLevel);
$ftp->rm($dir, true);
}
// Create directory just in case
$ret = $ftp->mkdir($dir, true);
if (@PEAR::isError($ret)) {
$ftp->disconnect();
throw new BuildException('Could not create directory ' . $dir . ': ' . $ret->getMessage());
}
$ret = $ftp->cd($dir);
if (@PEAR::isError($ret)) {
$ftp->disconnect();
throw new BuildException('Could not change to directory ' . $dir . ': ' . $ret->getMessage());
} else {
$this->log('Changed directory ' . $dir, $this->logLevel);
}
$fs = FileSystem::getFileSystem();
$convert = $fs->getSeparator() == '\\';
foreach ($this->filesets as $fs) {
// Array for holding directory content informations
$remoteFileInformations = array();
$ds = $fs->getDirectoryScanner($project);
$fromDir = $fs->getDir($project);
$srcFiles = $ds->getIncludedFiles();
$srcDirs = $ds->getIncludedDirectories();
foreach ($srcDirs as $dirname) {
if ($convert) {
$dirname = str_replace('\\', '/', $dirname);
}
// Read directory informations, if file exists, else create the directory
if (!$this->_directoryInformations($ftp, $remoteFileInformations, $dirname)) {
$this->log('Will create directory ' . $dirname, $this->logLevel);
$ret = $ftp->mkdir($dirname, true);
if (@PEAR::isError($ret)) {
$ftp->disconnect();
throw new BuildException('Could not create directory ' . $dirname . ': ' . $ret->getMessage());
}
}
if ($this->dirmode) {
if ($this->dirmode == 'inherit') {
$mode = fileperms($dirname);
} else {
$mode = $this->dirmode;
}
// Because Net_FTP does not support a chmod call we call ftp_chmod directly
ftp_chmod($ftp->_handle, $mode, $dirname);
}
}
foreach ($srcFiles as $filename) {
$file = new PhingFile($fromDir->getAbsolutePath(), $filename);
if ($convert) {
$filename = str_replace('\\', '/', $filename);
}
$local_filemtime = filemtime($file->getCanonicalPath());
if (isset($remoteFileInformations[$filename]['stamp'])) {
$remoteFileModificationTime = $remoteFileInformations[$filename]['stamp'];
} else {
$remoteFileModificationTime = 0;
}
if (!$this->depends || ($local_filemtime > $remoteFileModificationTime)) {
if ($this->skipOnSameSize === true && $file->length() === $ftp->size($filename)) {
$this->log('Skipped ' . $file->getCanonicalPath(), $this->logLevel);
continue;
}
$this->log('Will copy ' . $file->getCanonicalPath() . ' to ' . $filename, $this->logLevel);
$ret = $ftp->put($file->getCanonicalPath(), $filename, true, $this->mode);
if (@PEAR::isError($ret)) {
$ftp->disconnect();
throw new BuildException('Could not deploy file ' . $filename . ': ' . $ret->getMessage());
}
}
if ($this->filemode) {
if ($this->filemode == 'inherit') {
$mode = fileperms($filename);
} else {
$mode = $this->filemode;
}
// Because Net_FTP does not support a chmod call we call ftp_chmod directly
ftp_chmod($ftp->_handle, $mode, $filename);
}
}
}
$ftp->disconnect();
$this->log('Disconnected from FTP server', $this->logLevel);
}
/**
* @param Net_FTP $ftp
* @param $remoteFileInformations
* @param $directory
* @return bool
*/
private function _directoryInformations(Net_FTP $ftp, &$remoteFileInformations, $directory)
{
$content = $ftp->ls($directory);
if (@PEAR::isError($content)) {
if ($this->rawDataFallback) {
$content = $ftp->ls($directory, NET_FTP_RAWLIST);
}
if (@PEAR::isError($content)) {
return false;
}
$content = $this->parseRawFtpContent($content, $directory);
}
if (sizeof($content) == 0) {
return false;
} else {
if (!empty($directory)) {
$directory .= '/';
}
while (list(, $val) = each($content)) {
if ($val['name'] != '.' && $val['name'] != '..') {
$remoteFileInformations[$directory . $val['name']] = $val;
}
}
return true;
}
}
/**
* @param $content
* @param null $directory
* @return array
*/
private function parseRawFtpContent($content, $directory = null)
{
if (!is_array($content)) {
return array();
}
$this->log('Start parsing FTP_RAW_DATA in ' . $directory);
$retval = array();
foreach ($content as $rawInfo) {
$rawInfo = explode(' ', $rawInfo);
$rawInfo2 = array();
foreach ($rawInfo as $part) {
$part = trim($part);
if (!empty($part)) {
$rawInfo2[] = $part;
}
}
$date = date_parse($rawInfo2[5] . ' ' . $rawInfo2[6] . ' ' . $rawInfo2[7]);
if ($date['year'] === false) {
$date['year'] = date('Y');
}
$date = mktime(
$date['hour'],
$date['minute'],
$date['second'],
$date['month'],
$date['day'],
$date['year']
);
$retval[] = array(
'name' => $rawInfo2[8],
'rights' => substr($rawInfo2[0], 1),
'user' => $rawInfo2[2],
'group' => $rawInfo2[3],
'date' => $date,
'stamp' => $date,
'is_dir' => strpos($rawInfo2[0], 'd') === 0,
'files_inside' => (int) $rawInfo2[1],
'size' => (int) $rawInfo2[4],
);
}
$this->log('Finished parsing FTP_RAW_DATA in ' . $directory);
return $retval;
}
}
phing-2.14.0/tasks/ext/ReplaceRegexpTask.php 0000664 0001750 0001750 00000014653 12670364674 020552 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
/**
* ReplaceRegExp is a directory based task for replacing the occurrence of a
* given regular expression with a substitution pattern in a selected file or
* set of files.
*
*
*
*
*
* @author Jonathan Bond-Caron
*
* @package phing.tasks.system
*
* @link http://ant.apache.org/manual/OptionalTasks/replaceregexp.html
*/
class ReplaceRegexpTask extends Task
{
/** Single file to process. */
private $file;
/**
* Any filesets that should be processed.
*
* @var array $filesets
*/
private $filesets = array();
/**
* Regular expression
*
* @var RegularExpression
*/
private $_regexp;
/**
* File to apply regexp on
*
* @param PhingFile $path
*
* @return void
*/
public function setFile(PhingFile $path)
{
$this->file = $path;
}
/**
* Sets the regexp match pattern
*
* @param string $regexp
*
* @return void
*/
public function setMatch($regexp)
{
$this->_regexp->setPattern($regexp);
}
/**
* @see setMatch()
*
* @param $regexp
*
* @return void
*/
public function setPattern($regexp)
{
$this->setMatch($regexp);
}
/**
* Sets the replacement string
*
* @param string $string
*
* @return void
*/
public function setReplace($string)
{
$this->_regexp->setReplace($string);
}
/**
* Sets the regexp flags
*
* @param string $flags
*
* @return void
*
* todo ... `$this->_regexp->setFlags( $flags );`
*/
public function setFlags($flags)
{
}
/**
* Match only per line
*
* @param bool $yesNo
*
* @return void
*/
public function setByline($yesNo)
{
// TODO... $this->_regexp->
}
/**
* Nested adder, adds a set of files (nested fileset attribute).
*
* @param FileSet $fs
*
* @return void
*/
public function addFileSet(FileSet $fs)
{
$this->filesets[] = $fs;
}
/**
* {@inheritdoc}
*
* @return void
*/
public function init()
{
$this->_regexp = new RegularExpression();
}
/**
* {@inheritdoc}
*
* @return void
*
* @throws BuildException
*/
public function main()
{
if ($this->file === null && empty($this->filesets)) {
throw new BuildException("You must specify a file or fileset(s) for the task.");
}
// compile a list of all files to modify, both file attrib and fileset elements
// can be used.
$files = array();
if ($this->file !== null) {
$files[] = $this->file;
}
if (!empty($this->filesets)) {
$filenames = array();
foreach ($this->filesets as $fs) {
try {
$ds = $fs->getDirectoryScanner($this->project);
$filenames = $ds->getIncludedFiles(); // get included filenames
$dir = $fs->getDir($this->project);
foreach ($filenames as $fname) {
$files[] = new PhingFile($dir, $fname);
}
} catch (BuildException $be) {
$this->log($be->getMessage(), Project::MSG_WARN);
}
}
}
$this->log("Applying Regexp processing to " . count($files) . " files.");
// These "slots" allow filters to retrieve information about the currently-being-process files
$slot = $this->getRegisterSlot("currentFile");
$basenameSlot = $this->getRegisterSlot("currentFile.basename");
$filter = new FilterChain($this->project);
$r = new ReplaceRegexp();
$r->setRegexps(array($this->_regexp));
$filter->addReplaceRegexp($r);
$filters = array($filter);
foreach ($files as $file) {
// set the register slots
$slot->setValue($file->getPath());
$basenameSlot->setValue($file->getName());
// 1) read contents of file, pulling through any filters
$in = null;
try {
$contents = "";
$in = FileUtils::getChainedReader(new FileReader($file), $filters, $this->project);
while (-1 !== ($buffer = $in->read())) {
$contents .= $buffer;
}
$in->close();
} catch (Exception $e) {
if ($in) {
$in->close();
}
$this->log("Error reading file: " . $e->getMessage(), Project::MSG_WARN);
}
try {
// now create a FileWriter w/ the same file, and write to the file
$out = new FileWriter($file);
$out->write($contents);
$out->close();
$this->log("Applying regexp processing to " . $file->getPath(), Project::MSG_VERBOSE);
} catch (Exception $e) {
if ($out) {
$out->close();
}
$this->log("Error writing file back: " . $e->getMessage(), Project::MSG_WARN);
}
}
}
}
phing-2.14.0/tasks/ext/phpmd/PHPMDRendererRemoveFromCache.php 0000664 0001750 0001750 00000003704 12670364674 023571 0 ustar michiel michiel .
*/
require_once 'phing/util/DataStore.php';
use PHPMD\AbstractRenderer;
use PHPMD\Report;
/**
* This class will remove files with violations from cache
*
* @category PHP
* @package PHPMD
* @author Rui Filipe Da Cunha Alves
*/
class PHPMDRendererRemoveFromCache extends AbstractRenderer
{
/**
* Cache data storage
* @var DataStore
*/
protected $cache;
/**
* Constructor
*
* @param DataStore $cache
*/
public function __construct($cache)
{
$this->cache = $cache;
}
/**
* This method will be called when the engine has finished the source
* analysis phase. To remove file with violations from cache.
*
* @param Report $report
* @return void
*/
public function renderReport(Report $report)
{
foreach ($report->getRuleViolations() as $violation) {
$fileName = $violation->getFileName();
$this->cache->remove($fileName, null);
}
}
}
phing-2.14.0/tasks/ext/phpmd/PHPMDTask.php 0000664 0001750 0001750 00000024575 12670364674 020010 0 ustar michiel michiel .
*/
require_once 'phing/Task.php';
require_once 'phing/tasks/ext/phpmd/PHPMDFormatterElement.php';
/**
* Runs PHP Mess Detector. Checking PHP files for several potential problems
* based on rulesets.
*
* @package phing.tasks.ext.phpmd
* @author Benjamin Schultz
* @version $Id: 6de5c80e97545cd52494c53490e96c09aa61e703 $
* @since 2.4.1
*/
class PHPMDTask extends Task
{
/**
* A php source code filename or directory
*
* @var PhingFile
*/
protected $file = null;
/**
* All fileset objects assigned to this task
*
* @var FileSet[]
*/
protected $filesets = array();
/**
* The rule-set filenames or identifier.
*
* @var string
*/
protected $rulesets = 'codesize,unusedcode';
/**
* The minimum priority for rules to load.
*
* @var integer
*/
protected $minimumPriority = 0;
/**
* List of valid file extensions for analyzed files.
*
* @var array
*/
protected $allowedFileExtensions = array('php');
/**
* List of exclude directory patterns.
*
* @var array
*/
protected $ignorePatterns = array('.git', '.svn', 'CVS', '.bzr', '.hg');
/**
* The format for the report
*
* @var string
*/
protected $format = 'text';
/**
* Formatter elements.
*
* @var PHPMDFormatterElement[]
*/
protected $formatters = array();
/**
* @var bool
*/
protected $newVersion = true;
/**
* @var string
*/
protected $pharLocation = "";
/**
* Cache data storage
*
* @var DataStore
*/
protected $cache;
/**
* Set the input source file or directory.
*
* @param PhingFile $file The input source file or directory.
*/
public function setFile(PhingFile $file)
{
$this->file = $file;
}
/**
* Nested adder, adds a set of files (nested fileset attribute).
*
* @param FileSet $fs
* @return void
*/
public function addFileSet(FileSet $fs)
{
$this->filesets[] = $fs;
}
/**
* Sets the minimum rule priority.
*
* @param integer $minimumPriority Minimum rule priority.
*/
public function setMinimumPriority($minimumPriority)
{
$this->minimumPriority = $minimumPriority;
}
/**
* Sets the rule-sets.
*
* @param string $ruleSetFileNames Comma-separated string of rule-set filenames or identifier.
*/
public function setRulesets($ruleSetFileNames)
{
$this->rulesets = $ruleSetFileNames;
}
/**
* Sets a list of filename extensions for valid php source code files.
*
* @param string $fileExtensions List of valid file extensions without leading dot.
*/
public function setAllowedFileExtensions($fileExtensions)
{
$this->allowedFileExtensions = array();
$token = ' ,;';
$ext = strtok($fileExtensions, $token);
while ($ext !== false) {
$this->allowedFileExtensions[] = $ext;
$ext = strtok($token);
}
}
/**
* Sets a list of ignore patterns that is used to exclude directories from the source analysis.
*
* @param string $ignorePatterns List of ignore patterns.
*/
public function setIgnorePatterns($ignorePatterns)
{
$this->ignorePatterns = array();
$token = ' ,;';
$pattern = strtok($ignorePatterns, $token);
while ($pattern !== false) {
$this->ignorePatterns[] = $pattern;
$pattern = strtok($token);
}
}
/**
* Create object for nested formatter element.
*
* @return PHPMDFormatterElement
*/
public function createFormatter()
{
$num = array_push($this->formatters, new PHPMDFormatterElement());
return $this->formatters[$num - 1];
}
/**
* @param string $format
*/
public function setFormat($format)
{
$this->format = $format;
}
/**
* @param string $pharLocation
*/
public function setPharLocation($pharLocation)
{
$this->pharLocation = $pharLocation;
}
/**
* Whether to store last-modified times in cache
*
* @param PhingFile $file
*/
public function setCacheFile(PhingFile $file)
{
$this->cache = new DataStore($file);
}
/**
* Find PHPMD
*
* @return string
* @throws BuildException
*/
protected function loadDependencies()
{
if (!empty($this->pharLocation)) {
include_once 'phar://' . $this->pharLocation . '/vendor/autoload.php';
}
$className = '\PHPMD\PHPMD';
if (!class_exists($className)) {
@include_once 'PHP/PMD.php';
$className = "PHP_PMD";
$this->newVersion = false;
}
if (!class_exists($className)) {
throw new BuildException(
'PHPMDTask depends on PHPMD being installed and on include_path or listed in pharLocation.',
$this->getLocation()
);
}
if ($this->newVersion) {
//weird syntax to allow 5.2 parser compatibility
$minPriority = constant('\PHPMD\AbstractRule::LOWEST_PRIORITY');
require_once 'phing/tasks/ext/phpmd/PHPMDRendererRemoveFromCache.php';
} else {
require_once 'PHP/PMD/AbstractRule.php';
$minPriority = PHP_PMD_AbstractRule::LOWEST_PRIORITY;
}
if (!$this->minimumPriority) {
$this->minimumPriority = $minPriority;
}
return $className;
}
/**
* Return the list of files to parse
*
* @return string[] list of absolute files to parse
*/
protected function getFilesToParse()
{
$filesToParse = array();
if ($this->file instanceof PhingFile) {
$filesToParse[] = $this->file->getPath();
} else {
// append any files in filesets
foreach ($this->filesets as $fs) {
$dir = $fs->getDir($this->project)->getAbsolutePath();
foreach ($fs->getDirectoryScanner($this->project)->getIncludedFiles() as $filename) {
$fileAbsolutePath = $dir . DIRECTORY_SEPARATOR . $filename;
if ($this->cache) {
$lastMTime = $this->cache->get($fileAbsolutePath);
$currentMTime = filemtime($fileAbsolutePath);
if ($lastMTime >= $currentMTime) {
continue;
} else {
$this->cache->put($fileAbsolutePath, $currentMTime);
}
}
$filesToParse[] = $fileAbsolutePath;
}
}
}
return $filesToParse;
}
/**
* Executes PHPMD against PhingFile or a FileSet
*
* @throws BuildException - if the phpmd classes can't be loaded.
*/
public function main()
{
$className = $this->loadDependencies();
if (!isset($this->file) and count($this->filesets) == 0) {
throw new BuildException('Missing either a nested fileset or attribute "file" set');
}
if (count($this->formatters) == 0) {
// turn legacy format attribute into formatter
$fmt = new PHPMDFormatterElement();
$fmt->setType($this->format);
$fmt->setUseFile(false);
$this->formatters[] = $fmt;
}
$reportRenderers = array();
foreach ($this->formatters as $fe) {
if ($fe->getType() == '') {
throw new BuildException('Formatter missing required "type" attribute.');
}
if ($fe->getUsefile() && $fe->getOutfile() === null) {
throw new BuildException('Formatter requires "outfile" attribute when "useFile" is true.');
}
$reportRenderers[] = $fe->getRenderer();
}
if ($this->newVersion && $this->cache) {
$reportRenderers[] = new PHPMDRendererRemoveFromCache($this->cache);
} else {
$this->cache = null; // cache not compatible to old version
}
// Create a rule set factory
if ($this->newVersion) {
$ruleSetClass = '\PHPMD\RuleSetFactory';
$ruleSetFactory = new $ruleSetClass(); //php 5.2 parser compatibility
} else {
if (!class_exists("PHP_PMD_RuleSetFactory")) {
@include 'PHP/PMD/RuleSetFactory.php';
}
$ruleSetFactory = new PHP_PMD_RuleSetFactory();
}
$ruleSetFactory->setMinimumPriority($this->minimumPriority);
/**
* @var PHPMD\PHPMD $phpmd
*/
$phpmd = new $className();
$phpmd->setFileExtensions($this->allowedFileExtensions);
$phpmd->setIgnorePattern($this->ignorePatterns);
$filesToParse = $this->getFilesToParse();
if (count($filesToParse) > 0) {
$inputPath = implode(',', $filesToParse);
$this->log('Processing files...');
$phpmd->processFiles($inputPath, $this->rulesets, $reportRenderers, $ruleSetFactory);
if ($this->cache) {
$this->cache->commit();
}
$this->log('Finished processing files');
} else {
$this->log('No files to process');
}
}
}
phing-2.14.0/tasks/ext/phpmd/PHPMDFormatterElement.php 0000664 0001750 0001750 00000010730 12670364674 022347 0 ustar michiel michiel .
*/
require_once 'phing/system/io/PhingFile.php';
/**
* A wrapper for the implementations of PHPMDResultFormatter.
*
* @package phing.tasks.ext.phpmd
* @author Benjamin Schultz
