private function fixFile(\SplFileInfo $file, $dryRun) { $new = $old = file_get_contents($file->getRealpath()); $appliedFixers = []; Tokens::clearCache(); try { foreach ($this->fixers as $fixer) { if (!$fixer->supports($file)) { continue; } $newest = $fixer->fix($file, $new); if ($newest !== $new) { $appliedFixers[] = $fixer->getName(); } $new = $newest; } } catch (\Exception $e) { if ($this->errorsManager) { $this->errorsManager->report(ErrorsManager::ERROR_TYPE_EXCEPTION, $this->getFileRelativePathname($file), $e->__toString()); } return; } if ($new !== $old) { if (!$dryRun) { file_put_contents($file->getRealpath(), $new); } } return $appliedFixers; }
public function processFile(\SplFileInfo $file) { try { $parseResult = $this->parser->parse(new SourceFile($file->getRealpath())); if ($parseResult->hasRedeclarations() && !$this->tolerantMode) { throw new CollectorException(sprintf("Duplicate (potentially conditional) definitions of the following unit(s) found:\n\n\tUnit(s): %s\n\tFile: %s", join(', ', $parseResult->getRedeclarations()), $file->getRealPath()), CollectorException::InFileRedeclarationFound); } $this->collectorResult->addParseResult($file, $parseResult); } catch (ParserException $e) { throw new CollectorException(sprintf("Could not process file '%s' due to parse errors", $file->getRealPath()), CollectorException::ParseErrror, $e); } catch (CollectorResultException $e) { throw new CollectorException($e->getMessage(), CollectorException::RedeclarationFound); } }
/** * Get the size of a directory or a file * * @param SplFileInfo $file SplFileInfo instance * * @return int The calculated size */ function get_size(\SplFileInfo $file) { $size = 0; try { if ($file->isFile()) { $size += $file->getSize(); } else { foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($file->getRealpath())) as $f) { $size += $f->getSize(); } } } catch (\RuntimeException $e) { } return $size; }
public function fixFile(\SplFileInfo $file, array $fixers, $dryRun) { $new = $old = file_get_contents($file->getRealpath()); $appliedFixers = array(); foreach ($fixers as $fixer) { if (!$fixer->supports($file)) { continue; } $new1 = $fixer->fix($file, $new); if ($new1 != $new) { $appliedFixers[] = $fixer->getName(); } $new = $new1; } if ($new != $old) { if (!$dryRun) { file_put_contents($file->getRealpath(), $new); } return $appliedFixers; } }
/** * This method will create reflection class instances for all interfaces * and classes that can be found in the given source code files. * * @param string $pathnames The source directory that is the target of the * class search. * * @return Iterator */ public function find(array $paths) { $classes = array(); foreach ($paths as $path) { if (file_exists($path) === false || !is_file($path)) { throw new \LogicException('Invalid or nonexistent file ' . $path); } $fileInfo = new \SplFileInfo($path); $fileClasses = $this->parseFile($fileInfo->getRealpath()); $classes = array_merge($classes, $fileClasses); } return new \ArrayIterator($classes); }
/** * Get the total filesize for a given file or directory * * If $file is a file then just return the result of `filesize()`. * If $file is a directory then schedule a recursive filesize scan. * * @param \SplFileInfo $file The file or directory you want to know the size of * @param bool $skip_excluded_files Skip excluded files when calculating a directories total size * * @return int The total of the file or directory */ public function filesize(\SplFileInfo $file, $skip_excluded_files = false) { // Skip missing or unreadable files if (!file_exists($file->getPathname()) || !$file->getRealpath() || !$file->isReadable()) { return false; } // If it's a file then just pass back the filesize if ($file->isFile() && $file->isReadable()) { return $file->getSize(); } // If it's a directory then pull it from the cached filesize array if ($file->isDir()) { // If we haven't calculated the site size yet then kick it off in a thread $directory_sizes = get_transient('hmbkp_directory_filesizes'); if (!is_array($directory_sizes)) { if (!$this->is_site_size_being_calculated()) { // Mark the filesize as being calculated set_transient('hmbkp_directory_filesizes_running', true, HOUR_IN_SECONDS); // Schedule a Backdrop task to trigger a recalculation $task = new \HM\Backdrop\Task(array($this, 'recursive_filesize_scanner')); $task->schedule(); } return; } if ($this->backup->get_root() === $file->getPathname()) { return $directory_sizes[$file->getPathname()]; } $current_pathname = trailingslashit($file->getPathname()); $root = trailingslashit($this->backup->get_root()); foreach ($directory_sizes as $path => $size) { // Remove any files that aren't part of the current tree if (false === strpos($path, $current_pathname)) { unset($directory_sizes[$path]); } } if ($skip_excluded_files) { $excludes = $this->backup->exclude_string('regex'); foreach ($directory_sizes as $path => $size) { // Skip excluded files if we have excludes if ($excludes && preg_match('(' . $excludes . ')', str_ireplace($root, '', Backup::conform_dir($path)))) { unset($directory_sizes[$path]); } } } // Directory size is now just a sum of all files across all sub directories return array_sum($directory_sizes); } }
public function fixFile(\SplFileInfo $file, array $fixers, $dryRun, $diff, FileCacheManager $fileCacheManager) { $new = $old = file_get_contents($file->getRealpath()); if (!$fileCacheManager->needFixing($this->getFileRelativePathname($file), $old)) { if ($this->eventDispatcher) { $this->eventDispatcher->dispatch(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_SKIPPED)); } return; } if ($this->lintManager && !$this->lintManager->createProcessForFile($file->getRealpath())->isSuccessful()) { if ($this->eventDispatcher) { $this->eventDispatcher->dispatch(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_INVALID)); } return; } $appliedFixers = array(); // we do not need Tokens to still caching previously fixed file - so clear the cache Tokens::clearCache(); try { foreach ($fixers as $fixer) { if (!$fixer->supports($file)) { continue; } $newest = $fixer->fix($file, $new); if ($newest !== $new) { $appliedFixers[] = $fixer->getName(); } $new = $newest; } } catch (\Exception $e) { if ($this->eventDispatcher) { $this->eventDispatcher->dispatch(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_EXCEPTION)); } if ($this->errorsManager) { $this->errorsManager->report(ErrorsManager::ERROR_TYPE_EXCEPTION, $this->getFileRelativePathname($file), $e->__toString()); } return; } $fixInfo = null; if ($new !== $old) { if ($this->lintManager) { $lintProcess = $this->lintManager->createProcessForSource($new); if (!$lintProcess->isSuccessful()) { if ($this->eventDispatcher) { $this->eventDispatcher->dispatch(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_LINT)); } if ($this->errorsManager) { $this->errorsManager->report(ErrorsManager::ERROR_TYPE_LINT, $this->getFileRelativePathname($file), $lintProcess->getOutput()); } return; } } if (!$dryRun) { file_put_contents($file->getRealpath(), $new); } $fixInfo = array('appliedFixers' => $appliedFixers); if ($diff) { $fixInfo['diff'] = $this->stringDiff($old, $new); } } $fileCacheManager->setFile($this->getFileRelativePathname($file), $new); if ($this->eventDispatcher) { $this->eventDispatcher->dispatch(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus($fixInfo ? FixerFileProcessedEvent::STATUS_FIXED : FixerFileProcessedEvent::STATUS_NO_CHANGES)); } return $fixInfo; }
public function fixFile(\SplFileInfo $file, array $fixers, $dryRun, $diff) { $new = $old = file_get_contents($file->getRealpath()); $appliedFixers = array(); foreach ($fixers as $fixer) { if (!$fixer->supports($file)) { continue; } $new1 = $fixer->fix($file, $new); if ($new1 != $new) { $appliedFixers[] = $fixer->getName(); } $new = $new1; } if ($new != $old) { if (!$dryRun) { file_put_contents($file->getRealpath(), $new); } $fixInfo = array('appliedFixers' => $appliedFixers); if ($diff) { $fixInfo['diff'] = $this->stringDiff($old, $new); } return $fixInfo; } }
/** * Uploads a file or directory to an FTP connection. * * @param \Ftp $ftp An active FTP connection. * @param \SplFileInfo $file A local file to upload. */ protected function upload(\Ftp $ftp, \SplFileInfo $file) { // enter into passive mode $ftp->pasv(true); // move to the file's parent directory $ftp->chdir($this->targetDirectory . '/' . $file->getRelativePath()); // check if the file exists $fileExists = in_array($file->getBasename(), $ftp->nlist('.')); // check if the file is a directory if ($file->isDir()) { // create the directory if it does not exist if (!$fileExists) { $this->printTaskInfo('Creating directory: ' . $file->getRelativePathname()); // create directory $ftp->mkdir($file->getBasename()); } } else { // if the file already exists, check our skip options if ($fileExists) { // skip the file if the file sizes are equal if ($this->skipSizeEqual && $ftp->size($file->getBasename()) === $file->getSize()) { return; } // skip the file if modified time is same or newer than source if ($this->skipUnmodified && $ftp->mdtm($file->getBasename()) >= $file->getMTime()) { return; } } // try to upload the file $this->printTaskInfo('Uploading: ' . $file->getRelativePathname()); if (!$ftp->put($file->getBasename(), $file->getRealpath(), FTP_BINARY)) { // something went wrong return Result::error($this, 'Failed while uploading file ' . $file->getRelativePathname()); } } }
public function conVertFile(\SplFileInfo $file, array $converter, $dryRun, $diff, $outputExt) { $new = $old = file_get_contents($file->getRealpath()); $appliedConverters = array(); foreach ($converter as $convert) { if (!$convert->supports($file)) { continue; } $new1 = $convert->convert($file, $new); if ($new1 != $new) { $appliedConverters[] = $convert->getName(); } $new = $new1; } if ($new != $old) { if (!$dryRun) { $filename = $file->getRealpath(); $ext = strrchr($filename, '.'); if ($outputExt) { $filename = rtrim($filename, $ext) . '.' . trim($outputExt, '.'); } file_put_contents($filename, $new); } $fixInfo = array('appliedConverters' => $appliedConverters); if ($diff) { $fixInfo['diff'] = $this->stringDiff($old, $new); } return $fixInfo; } }
/** * @param \Yosmanyga\Resource\Resource $resource * @param \SplFileInfo $file * @return \Yosmanyga\Resource\Resource */ private function convertResource(Resource $resource, \SplFileInfo $file) { return new Resource(array_merge($resource->getMetadata(), array('file' => $file->getRealpath())), $resource->getMetadata('type')); }
private function _tryToBuildAddonFromFile(SplFileInfo $infoFile) { $manifestFilePath = realpath("{$infoFile}"); $infoFileContents = @json_decode(file_get_contents($manifestFilePath), true); $shouldLog = $this->_logger->isHandling(ehough_epilog_Logger::DEBUG); if ($infoFileContents === null || $infoFileContents === false || empty($infoFileContents)) { if ($shouldLog) { $this->_logger->debug('Could not parse add-on manifest file at ' . $manifestFilePath); } return null; } try { return $this->_constructAddonFromArray($infoFileContents, $manifestFilePath); } catch (Exception $e) { if ($shouldLog) { $this->_logger->warn('Caught exception when parsing info file at ' . $infoFile->getRealpath() . ': ' . $e->getMessage()); } return null; } }
public function fixFile(\SplFileInfo $file, array $fixers, $dryRun, $diff, FileCacheManager $fileCacheManager) { $new = $old = file_get_contents($file->getRealpath()); if ('' === $old || !$fileCacheManager->needFixing($this->getFileRelativePathname($file), $old) || PHP_VERSION_ID >= 50306 && PHP_VERSION_ID < 50400 && false !== stripos($old, '__halt_compiler()')) { $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_SKIPPED)); return; } try { $this->linter->lintFile($file->getRealpath()); } catch (LintingException $e) { $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_INVALID)); $this->errorsManager->report(new Error(Error::TYPE_INVALID, $this->getFileRelativePathname($file))); return; } $old = file_get_contents($file->getRealpath()); $appliedFixers = array(); // we do not need Tokens to still caching previously fixed file - so clear the cache Tokens::clearCache(); $tokens = Tokens::fromCode($old); $newHash = $oldHash = $tokens->getCodeHash(); try { foreach ($fixers as $fixer) { if (!$fixer->supports($file) || !$fixer->isCandidate($tokens)) { continue; } $fixer->fix($file, $tokens); if ($tokens->isChanged()) { $tokens->clearEmptyTokens(); $tokens->clearChanged(); $appliedFixers[] = $fixer->getName(); } } } catch (\Exception $e) { $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_EXCEPTION)); $this->errorsManager->report(new Error(Error::TYPE_EXCEPTION, $this->getFileRelativePathname($file))); return; } $fixInfo = null; if (!empty($appliedFixers)) { $new = $tokens->generateCode(); $newHash = $tokens->getCodeHash(); } // We need to check if content was changed and then applied changes. // But we can't simple check $appliedFixers, because one fixer may revert // work of other and both of them will mark collection as changed. // Therefore we need to check if code hashes changed. if ($oldHash !== $newHash) { try { $this->linter->lintSource($new); } catch (LintingException $e) { $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_LINT)); $this->errorsManager->report(new Error(Error::TYPE_LINT, $this->getFileRelativePathname($file))); return; } if (!$dryRun && false === @file_put_contents($file->getRealpath(), $new)) { $error = error_get_last(); if ($error) { throw new IOException(sprintf('Failed to write file "%s", "%s".', $file->getRealpath(), $error['message']), 0, null, $file->getRealpath()); } throw new IOException(sprintf('Failed to write file "%s".', $file->getRealpath()), 0, null, $file->getRealpath()); } $fixInfo = array('appliedFixers' => $appliedFixers); if ($diff) { $fixInfo['diff'] = $this->stringDiff($old, $new); } } $fileCacheManager->setFile($this->getFileRelativePathname($file), $new); $this->dispatchEvent(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus($fixInfo ? FixerFileProcessedEvent::STATUS_FIXED : FixerFileProcessedEvent::STATUS_NO_CHANGES)); return $fixInfo; }
public function fixFile(\SplFileInfo $file, array $fixers, $dryRun, $diff, FileCacheManager $fileCacheManager) { $new = $old = file_get_contents($file->getRealpath()); if (!$fileCacheManager->needFixing($this->getFileRelativePathname($file), $old)) { if ($this->eventDispatcher) { $this->eventDispatcher->dispatch(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus(FixerFileProcessedEvent::STATUS_SKIPPED)); } return; } $appliedFixers = array(); // we do not need Tokens to still caching previously fixed file - so clear the cache Tokens::clearCache(); foreach ($fixers as $fixer) { if (!$fixer->supports($file)) { continue; } $newest = $fixer->fix($file, $new); if ($newest !== $new) { $appliedFixers[] = $fixer->getName(); } $new = $newest; } $fixInfo = null; if ($new !== $old) { if (!$dryRun) { file_put_contents($file->getRealpath(), $new); } $fixInfo = array('appliedFixers' => $appliedFixers); if ($diff) { $fixInfo['diff'] = $this->stringDiff($old, $new); } } $fileCacheManager->setFile($this->getFileRelativePathname($file), $new); if ($this->eventDispatcher) { $this->eventDispatcher->dispatch(FixerFileProcessedEvent::NAME, FixerFileProcessedEvent::create()->setStatus($fixInfo ? FixerFileProcessedEvent::STATUS_FIXED : FixerFileProcessedEvent::STATUS_NO_CHANGES)); } return $fixInfo; }
public function updateContentDir(DOMElement $parent, SplFileInfo $directory, $role) { $dir = $parent->ownerDocument->createElement('dir'); $dir->setAttribute('name', $directory->getFilename()); if ($this->basedir) { $dir->setAttribute('baseinstalldir', $this->basedir); } $parent->appendChild($dir); foreach (new DirectoryIterator($directory->getRealpath()) as $file) { if ($file->isDot()) { continue; } else { if ($file->isDir()) { $this->updateContentDir($dir, $file, $role); } else { $this->updateContentFile($dir, $file, $role); } } } return $parent; }
/** * @param SplFileInfo $value1 * @param SplFileInfo $value2 * @return int */ protected function compare($value1, $value2) { return strcasecmp($value2->getRealpath(), $value1->getRealpath()); }
public function _callbackGetAcceptData(SplFileInfo $a, SplFileInfo $b) { return strcmp($a->getRealpath(), $b->getRealpath()); }
public function _callbackTestSort(SplFileInfo $a, SplFileInfo $b) { return strcmp($a->getRealpath(), $b->getRealpath()); }
/** * Get the total filesize for a given file or directory. Aware of exclusions. * * If $file is a file then return the result of `filesize()` or 0 if it's excluded. * If $file is a directory then recursively calculate the size without * the size of excluded files/directories. * * @param \SplFileInfo $file The file or directory you want to know the size of. * * @return int The total filesize of the file or directory without * the size of excluded files/directories. */ public function filesize(\SplFileInfo $file) { // Skip missing or unreadable files. if (!file_exists($file->getPathname()) || !$file->getRealpath() || !$file->isReadable()) { return 0; } // If it's a file then return its filesize or 0 if it's excluded. if ($file->isFile()) { if ($this->excludes && $this->excludes->is_file_excluded($file)) { return 0; } else { return $file->getSize(); } } // If it's a directory then pull it from the cached filesize array. if ($file->isDir()) { return $this->directory_filesize($file); } }
/** * Get the total filesize for a given file or directory * * If $file is a file then just return the result of `filesize()`. * If $file is a directory then recursively calculate the size. * * @param \SplFileInfo $file The file or directory you want to know the size of * * @return int The total filesize of the file or directory */ public function filesize(\SplFileInfo $file) { // Skip missing or unreadable files if (!file_exists($file->getPathname()) || !$file->getRealpath() || !$file->isReadable()) { return 0; } // If it's a file then just pass back the filesize if ($file->isFile()) { return $file->getSize(); } // If it's a directory then pull it from the cached filesize array if ($file->isDir()) { return $this->directory_filesize($file); } }
private function wasModifiedSinceLastRun(SplFileInfo $file) { return filemtime($file->getRealpath()) > self::$lastTime; }