/**
* Executes the task
*
* @param array $uParameters parameters
*
* @return int exit code
*/
public function executeTask(array $uParameters)
{
$tPath = Core::$instance->loader->basepath . "/var/cache";
FileSystem::garbageCollect($tPath, ["dotFiles" => false]);
$this->interface->writeColor("yellow", "done.");
return 0;
}
/**
* Loads a yaml configuration and adds it to stack
*
* @param string $uProjectConfigPath The path of yaml configuration file
*
* @return void
*
* @todo use cached reader and cache yaml
*/
public function addConfig($uPath)
{
if ($this->yamlParser === null) {
$this->yamlParser = new Parser();
}
$tYaml = $this->yamlParser->parse(FileSystem::read($uPath));
$this->config->add($tYaml);
}
/**
* Scans a file
*
* @param string $uFile file path
*
* @return void
*/
public function processFile($uFile)
{
$tFileContents = FileSystem::read($uFile);
foreach ($this->scanners as $tScanner) {
$tScanner->processFile($uFile, $tFileContents);
}
$tTokenStream = TokenStream::fromString($tFileContents);
$this->processTokenStream($tTokenStream);
}
/**
* Compiles given configuration files into single configuration
*
* @return array final configuration
*/
public function get()
{
// TODO mass caching with pathnames and flags
foreach ($this->paths as $tPath) {
$tConfigPath = Core::$instance->translateVariables($tPath[0]);
$tConfigContent = Core::$instance->cachedRead("file." . realpath($tConfigPath), function () use($tConfigPath) {
$tParser = new Parser();
return $tParser->parse(FileSystem::read($tConfigPath));
}, ["ttl" => 60 * 60]);
$this->process($this->content, $tConfigContent, $tPath[1]);
}
return $this->content;
}
/**
* Stops the code coverage
*
* @return array results
*/
public static function coverageStop()
{
if (!extension_loaded("xdebug")) {
return null;
}
$tCoverageData = xdebug_get_code_coverage();
xdebug_stop_code_coverage();
$tFinal = ["files" => [], "total" => ["coveredLines" => 0, "totalLines" => 0]];
foreach ($tCoverageData as $tPath => $tLines) {
$tFileCoverage = ["path" => $tPath, "coveredLines" => array_keys($tLines), "totalLines" => FileSystem::getFileLineCount($tPath)];
$tFinal["files"][] = $tFileCoverage;
$tFinal["total"]["coveredLines"] += count($tFileCoverage["coveredLines"]);
$tFinal["total"]["totalLines"] += $tFileCoverage["totalLines"];
}
$tFinal["total"]["percentage"] = $tFinal["total"]["coveredLines"] * 100 / $tFinal["total"]["totalLines"];
return $tFinal;
}
/**
* Scans given file to search for classes
*
* @param string $uFile file
* @param string $uNamespacePrefix namespace prefix
*
* @return void
*/
public function scanFile($uFile, $uNamespacePrefix)
{
$tFileContents = FileSystem::read($uFile);
$tTokenStream = TokenStream::fromString($tFileContents);
$this->annotationScanner->process($tTokenStream, $uNamespacePrefix);
}
/**
* Compiles given configuration files into single configuration
*
* @param null|string $uMimeTypeFilter only compiles filtered mimetypes
*
* @return void
*/
public function compile($uMimeTypeFilter = null)
{
if (count($this->contents) > 0) {
$this->output = "";
foreach ($this->contents as $tContent) {
if ($uMimeTypeFilter !== null && $uMimeTypeFilter !== $tContent[1]) {
continue;
}
if ($tContent[0] === "direct") {
$tOutput = $tContent[2];
} elseif ($tContent[0] === "callback") {
$tOutput = call_user_func($tContent[2]);
} elseif ($tContent[0] === "file") {
$tOutput = FileSystem::read($tContent[2]);
}
if (isset($this->filters[$tContent[1]])) {
$tOutput = call_user_func($this->filters[$tContent[1]], $tOutput);
}
$this->output .= $tOutput;
}
$this->contents = [];
}
return $this->output;
}
/**
* Saves a file into writable folder
*
* @param string $uFilename filename
* @param mixed $uContent file content to be written
* @param bool $uSaveAsPHP saves file contents as php file if it is true
*
* @return void
*/
public function saveFile($uFilename, $uContent, $uSaveAsPHP = false)
{
if ($uSaveAsPHP) {
FileSystem::writePhpFile(Core::$instance->translateVariables($this->applicationWritablePath . "/{$uFilename}"), $uContent);
return;
}
FileSystem::write(Core::$instance->translateVariables($this->applicationWritablePath . "/{$uFilename}"), $uContent);
}
/**
* Reads the contents from cache folder as long as it is not expired
* If the file is expired, invokes callback method and caches output
*
* @param string $uKey key for the value going to be cached
* @param mixed $uDefaultValue the default value
* @param array $uOptions options
*
* @return mixed the result
*/
public function cachedRead($uKey, $uDefaultValue, array $uOptions = [])
{
$tCacheFile = $this->loader->basepath . "/var/cache/" . crc32($uKey);
return FileSystem::readFromCacheFile($tCacheFile, $uDefaultValue, $uOptions);
}
