2011-03-26 07:37:25 +00:00
|
|
|
<?php
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This file is part of the Symfony package.
|
|
|
|
*
|
|
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
|
|
|
*
|
|
|
|
* For the full copyright and license information, please view the LICENSE
|
|
|
|
* file that was distributed with this source code.
|
|
|
|
*/
|
|
|
|
|
2011-12-22 18:36:46 +00:00
|
|
|
namespace Symfony\Component\Filesystem;
|
2011-03-26 07:37:25 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Provides basic utility to manipulate the file system.
|
|
|
|
*
|
|
|
|
* @author Fabien Potencier <fabien@symfony.com>
|
|
|
|
*/
|
|
|
|
class Filesystem
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* Copies a file.
|
|
|
|
*
|
|
|
|
* This method only copies the file if the origin file is newer than the target file.
|
|
|
|
*
|
|
|
|
* By default, if the target already exists, it is not overridden.
|
|
|
|
*
|
2011-04-23 16:05:44 +01:00
|
|
|
* @param string $originFile The original filename
|
|
|
|
* @param string $targetFile The target filename
|
|
|
|
* @param array $override Whether to override an existing file or not
|
2011-03-26 07:37:25 +00:00
|
|
|
*/
|
|
|
|
public function copy($originFile, $targetFile, $override = false)
|
|
|
|
{
|
|
|
|
$this->mkdir(dirname($targetFile));
|
|
|
|
|
2011-09-04 08:28:37 +01:00
|
|
|
if (!$override && is_file($targetFile)) {
|
2011-08-26 09:34:23 +01:00
|
|
|
$doCopy = filemtime($originFile) > filemtime($targetFile);
|
|
|
|
} else {
|
|
|
|
$doCopy = true;
|
2011-03-26 07:37:25 +00:00
|
|
|
}
|
|
|
|
|
2011-08-26 09:34:23 +01:00
|
|
|
if ($doCopy) {
|
2011-03-26 07:37:25 +00:00
|
|
|
copy($originFile, $targetFile);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a directory recursively.
|
|
|
|
*
|
|
|
|
* @param string|array|\Traversable $dirs The directory path
|
|
|
|
* @param int $mode The directory mode
|
|
|
|
*
|
|
|
|
* @return Boolean true if the directory has been created, false otherwise
|
|
|
|
*/
|
|
|
|
public function mkdir($dirs, $mode = 0777)
|
|
|
|
{
|
2011-03-27 18:17:13 +01:00
|
|
|
$ret = true;
|
2011-03-26 07:37:25 +00:00
|
|
|
foreach ($this->toIterator($dirs) as $dir) {
|
|
|
|
if (is_dir($dir)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
$ret = @mkdir($dir, $mode, true) && $ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates empty files.
|
|
|
|
*
|
2012-04-07 00:05:37 +01:00
|
|
|
* @param string|array|\Traversable $files A filename, an array of files, or a \Traversable instance to create
|
2011-03-26 07:37:25 +00:00
|
|
|
*/
|
|
|
|
public function touch($files)
|
|
|
|
{
|
|
|
|
foreach ($this->toIterator($files) as $file) {
|
|
|
|
touch($file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes files or directories.
|
|
|
|
*
|
|
|
|
* @param string|array|\Traversable $files A filename, an array of files, or a \Traversable instance to remove
|
|
|
|
*/
|
|
|
|
public function remove($files)
|
|
|
|
{
|
|
|
|
$files = iterator_to_array($this->toIterator($files));
|
|
|
|
$files = array_reverse($files);
|
|
|
|
foreach ($files as $file) {
|
2012-04-07 00:01:32 +01:00
|
|
|
if (!file_exists($file) && !is_link($file)) {
|
2011-03-26 07:37:25 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_dir($file) && !is_link($file)) {
|
|
|
|
$this->remove(new \FilesystemIterator($file));
|
|
|
|
|
|
|
|
rmdir($file);
|
|
|
|
} else {
|
|
|
|
unlink($file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Change mode for an array of files or directories.
|
|
|
|
*
|
2012-04-07 00:05:37 +01:00
|
|
|
* @param string|array|\Traversable $files A filename, an array of files, or a \Traversable instance to change mode
|
2011-03-26 07:37:25 +00:00
|
|
|
* @param integer $mode The new mode
|
|
|
|
* @param integer $umask The mode mask (octal)
|
|
|
|
*/
|
|
|
|
public function chmod($files, $mode, $umask = 0000)
|
|
|
|
{
|
|
|
|
$currentUmask = umask();
|
|
|
|
umask($umask);
|
|
|
|
|
2011-03-26 11:54:13 +00:00
|
|
|
foreach ($this->toIterator($files) as $file) {
|
2011-03-26 07:37:25 +00:00
|
|
|
chmod($file, $mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
umask($currentUmask);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Renames a file.
|
|
|
|
*
|
|
|
|
* @param string $origin The origin filename
|
|
|
|
* @param string $target The new filename
|
|
|
|
*
|
|
|
|
* @throws \RuntimeException When target file already exists
|
|
|
|
*/
|
|
|
|
public function rename($origin, $target)
|
|
|
|
{
|
|
|
|
// we check that target does not exist
|
|
|
|
if (is_readable($target)) {
|
2011-12-09 17:49:17 +00:00
|
|
|
throw new \RuntimeException(sprintf('Cannot rename because the target "%s" already exist.', $target));
|
2011-03-26 07:37:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rename($origin, $target);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a symbolic link or copy a directory.
|
|
|
|
*
|
2011-04-23 16:05:44 +01:00
|
|
|
* @param string $originDir The origin directory path
|
|
|
|
* @param string $targetDir The symbolic link name
|
2011-08-26 09:34:23 +01:00
|
|
|
* @param Boolean $copyOnWindows Whether to copy files if on Windows
|
2011-03-26 07:37:25 +00:00
|
|
|
*/
|
|
|
|
public function symlink($originDir, $targetDir, $copyOnWindows = false)
|
|
|
|
{
|
|
|
|
if (!function_exists('symlink') && $copyOnWindows) {
|
|
|
|
$this->mirror($originDir, $targetDir);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
$ok = false;
|
|
|
|
if (is_link($targetDir)) {
|
|
|
|
if (readlink($targetDir) != $originDir) {
|
|
|
|
unlink($targetDir);
|
|
|
|
} else {
|
|
|
|
$ok = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$ok) {
|
|
|
|
symlink($originDir, $targetDir);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-28 16:31:08 +01:00
|
|
|
/**
|
|
|
|
* Given an existing path, convert it to a path relative to a given starting path
|
|
|
|
*
|
2012-04-07 00:05:37 +01:00
|
|
|
* @param string $endPath Absolute path of target
|
|
|
|
* @param string $startPath Absolute path where traversal begins
|
2011-09-28 16:31:08 +01:00
|
|
|
*
|
|
|
|
* @return string Path of target relative to starting path
|
|
|
|
*/
|
|
|
|
public function makePathRelative($endPath, $startPath)
|
|
|
|
{
|
|
|
|
// Find for which character the the common path stops
|
|
|
|
$offset = 0;
|
2012-04-07 08:23:20 +01:00
|
|
|
while (isset($startPath[$offset]) && isset($endPath[$offset]) && $startPath[$offset] === $endPath[$offset]) {
|
2011-09-28 16:31:08 +01:00
|
|
|
$offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Determine how deep the start path is relative to the common path (ie, "web/bundles" = 2 levels)
|
2012-04-07 21:19:12 +01:00
|
|
|
$diffPath = trim(substr($startPath, $offset), DIRECTORY_SEPARATOR);
|
2012-04-07 21:52:26 +01:00
|
|
|
$depth = strlen($diffPath) > 0 ? substr_count($diffPath, DIRECTORY_SEPARATOR) + 1 : 0;
|
2011-09-28 16:31:08 +01:00
|
|
|
|
|
|
|
// Repeated "../" for each level need to reach the common path
|
|
|
|
$traverser = str_repeat('../', $depth);
|
|
|
|
|
|
|
|
// Construct $endPath from traversing to the common path, then to the remaining $endPath
|
|
|
|
return $traverser.substr($endPath, $offset);
|
|
|
|
}
|
|
|
|
|
2011-03-26 07:37:25 +00:00
|
|
|
/**
|
|
|
|
* Mirrors a directory to another.
|
|
|
|
*
|
|
|
|
* @param string $originDir The origin directory
|
|
|
|
* @param string $targetDir The target directory
|
|
|
|
* @param \Traversable $iterator A Traversable instance
|
2011-08-26 09:47:18 +01:00
|
|
|
* @param array $options An array of boolean options
|
|
|
|
* Valid options are:
|
|
|
|
* - $options['override'] Whether to override an existing file on copy or not (see copy())
|
|
|
|
* - $options['copy_on_windows'] Whether to copy files instead of links on Windows (see symlink())
|
2011-03-26 07:37:25 +00:00
|
|
|
*
|
|
|
|
* @throws \RuntimeException When file type is unknown
|
|
|
|
*/
|
|
|
|
public function mirror($originDir, $targetDir, \Traversable $iterator = null, $options = array())
|
|
|
|
{
|
2011-08-26 09:47:18 +01:00
|
|
|
$copyOnWindows = false;
|
|
|
|
if (isset($options['copy_on_windows']) && !function_exists('symlink')) {
|
|
|
|
$copyOnWindows = $options['copy_on_windows'];
|
|
|
|
}
|
|
|
|
|
2011-03-26 07:37:25 +00:00
|
|
|
if (null === $iterator) {
|
2011-08-26 09:47:18 +01:00
|
|
|
$flags = $copyOnWindows ? \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS : \FilesystemIterator::SKIP_DOTS;
|
|
|
|
$iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($originDir, $flags), \RecursiveIteratorIterator::SELF_FIRST);
|
2011-03-26 07:37:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ('/' === substr($targetDir, -1) || '\\' === substr($targetDir, -1)) {
|
|
|
|
$targetDir = substr($targetDir, 0, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ('/' === substr($originDir, -1) || '\\' === substr($originDir, -1)) {
|
|
|
|
$originDir = substr($originDir, 0, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($iterator as $file) {
|
|
|
|
$target = $targetDir.'/'.str_replace($originDir.DIRECTORY_SEPARATOR, '', $file->getPathname());
|
|
|
|
|
2011-10-25 09:58:39 +01:00
|
|
|
if (is_link($file)) {
|
|
|
|
$this->symlink($file, $target);
|
2011-12-18 13:42:59 +00:00
|
|
|
} elseif (is_dir($file)) {
|
2011-03-26 07:37:25 +00:00
|
|
|
$this->mkdir($target);
|
2011-12-18 13:42:59 +00:00
|
|
|
} elseif (is_file($file) || ($copyOnWindows && is_link($file))) {
|
2011-08-26 09:47:18 +01:00
|
|
|
$this->copy($file, $target, isset($options['override']) ? $options['override'] : false);
|
2011-03-26 07:37:25 +00:00
|
|
|
} else {
|
|
|
|
throw new \RuntimeException(sprintf('Unable to guess "%s" file type.', $file));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-31 10:04:23 +01:00
|
|
|
/**
|
|
|
|
* Returns whether the file path is an absolute path.
|
|
|
|
*
|
|
|
|
* @param string $file A file path
|
|
|
|
*
|
|
|
|
* @return Boolean
|
|
|
|
*/
|
|
|
|
public function isAbsolutePath($file)
|
|
|
|
{
|
|
|
|
if ($file[0] == '/' || $file[0] == '\\'
|
|
|
|
|| (strlen($file) > 3 && ctype_alpha($file[0])
|
|
|
|
&& $file[1] == ':'
|
|
|
|
&& ($file[2] == '\\' || $file[2] == '/')
|
|
|
|
)
|
2011-12-08 12:44:49 +00:00
|
|
|
|| null !== parse_url($file, PHP_URL_SCHEME)
|
2011-05-31 10:04:23 +01:00
|
|
|
) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-04-06 17:48:01 +01:00
|
|
|
/**
|
|
|
|
* @param mixed $files
|
|
|
|
*
|
|
|
|
* @return \Traversable
|
|
|
|
*/
|
2011-03-26 07:37:25 +00:00
|
|
|
private function toIterator($files)
|
|
|
|
{
|
|
|
|
if (!$files instanceof \Traversable) {
|
|
|
|
$files = new \ArrayObject(is_array($files) ? $files : array($files));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $files;
|
|
|
|
}
|
|
|
|
}
|