1. sfFilesystem.class.php
  2. /**
 * sfFilesystem provides basic utility to manipulate the file system.
 *
 * @package    symfony
 * @subpackage util
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfFilesystem.class.php 24991 2009-12-06 20:22:52Z Kris.Wallsmith $
 */
  3. class sfFilesystem
  4. {
  5.   protected
  6.     $dispatcher = null,
  7.     $formatter  = null;
  9.   /**
  10.    * Constructor.
  11.    *
  12.    * @param sfEventDispatcher $dispatcher  An sfEventDispatcher instance
  13.    * @param sfFormatter       $formatter   An sfFormatter instance
  14.    */
  15.   public function __construct(sfEventDispatcher $dispatcher = null, sfFormatter $formatter = null)
  16.   {
  17.     $this->dispatcher = $dispatcher;
  18.     $this->formatter = $formatter;
  19.   }
  21.   /**
  22.    * Copies a file.
  23.    *
  24.    * This method only copies the file if the origin file is newer than the target file.
  25.    *
  26.    * By default, if the target already exists, it is not overriden.
  27.    *
  28.    * To override existing files, pass the "override" option.
  29.    *
  30.    * @param string $originFile  The original filename
  31.    * @param string $targetFile  The target filename
  32.    * @param array  $options     An array of options
  33.    */
  34.   public function copy($originFile, $targetFile, $options = array())
  35.   {
  36.     if (!array_key_exists('override', $options))
  37.     {
  38.       $options['override'] = false;
  39.     }
  41.     // we create target_dir if needed
  42.     if (!is_dir(dirname($targetFile)))
  43.     {
  44.       $this->mkdirs(dirname($targetFile));
  45.     }
  47.     $mostRecent = false;
  48.     if (file_exists($targetFile))
  49.     {
  50.       $statTarget = stat($targetFile);
  51.       $stat_origin = stat($originFile);
  52.       $mostRecent = ($stat_origin['mtime'] > $statTarget['mtime']) ? true : false;
  53.     }
  55.     if ($options['override'] || !file_exists($targetFile) || $mostRecent)
  56.     {
  57.       $this->logSection('file+', $targetFile);
  58.       copy($originFile, $targetFile);
  59.     }
  60.   }
  62.   /**
  63.    * Creates a directory recursively.
  64.    *
  65.    * @param  string $path  The directory path
  66.    * @param  int    $mode  The directory mode
  67.    *
  68.    * @return bool true if the directory has been created, false otherwise
  69.    */
  70.   public function mkdirs($path, $mode = 0777)
  71.   {
  72.     if (is_dir($path))
  73.     {
  74.       return true;
  75.     }
  77.     $this->logSection('dir+', $path);
  79.     return @mkdir($path, $mode, true);
  80.   }
  82.   /**
  83.    * Creates empty files.
  84.    *
  85.    * @param mixed $files  The filename, or an array of filenames
  86.    */
  87.   public function touch($files)
  88.   {
  89.     if (!is_array($files))
  90.     {
  91.       $files = array($files);
  92.     }
  94.     foreach ($files as $file)
  95.     {
  96.       $this->logSection('file+', $file);
  98.       touch($file);
  99.     }
  100.   }
  102.   /**
  103.    * Removes files or directories.
  104.    *
  105.    * @param mixed $files  A filename or an array of files to remove
  106.    */
  107.   public function remove($files)
  108.   {
  109.     if (!is_array($files))
  110.     {
  111.       $files = array($files);
  112.     }
  114.     $files = array_reverse($files);
  115.     foreach ($files as $file)
  116.     {
  117.       if (is_dir($file) && !is_link($file))
  118.       {
  119.         $this->logSection('dir-', $file);
  121.         rmdir($file);
  122.       }
  123.       else
  124.       {
  125.         $this->logSection(is_link($file) ? 'link-' : 'file-', $file);
  127.         unlink($file);
  128.       }
  129.     }
  130.   }
  132.   /**
  133.    * Change mode for an array of files or directories.
  134.    *
  135.    * @param array   $files  An array of files or directories
  136.    * @param integer $mode   The new mode
  137.    * @param integer $umask  The mode mask (octal)
  138.    */
  139.   public function chmod($files, $mode, $umask = 0000)
  140.   {
  141.     $currentUmask = umask();
  142.     umask($umask);
  144.     if (!is_array($files))
  145.     {
  146.       $files = array($files);
  147.     }
  149.     foreach ($files as $file)
  150.     {
  151.       $this->logSection(sprintf('chmod %o', $mode), $file);
  152.       chmod($file, $mode);
  153.     }
  155.     umask($currentUmask);
  156.   }
  158.   /**
  159.    * Renames a file.
  160.    *
  161.    * @param string $origin  The origin filename
  162.    * @param string $target  The new filename
  163.    */
  164.   public function rename($origin, $target)
  165.   {
  166.     // we check that target does not exist
  167.     if (is_readable($target))
  168.     {
  169.       throw new sfException(sprintf('Cannot rename because the target "%" already exist.', $target));
  170.     }
  172.     $this->logSection('rename', $origin.' > '.$target);
  173.     rename($origin, $target);
  174.   }
  176.   /**
  177.    * Creates a symbolic link or copy a directory.
  178.    *
  179.    * @param string $originDir      The origin directory path
  180.    * @param string $targetDir      The symbolic link name
  181.    * @param bool   $copyOnWindows  Whether to copy files if on windows
  182.    */
  183.   public function symlink($originDir, $targetDir, $copyOnWindows = false)
  184.   {
  185.     if (!function_exists('symlink') && $copyOnWindows)
  186.     {
  187.       $finder = sfFinder::type('any');
  188.       $this->mirror($originDir, $targetDir, $finder);
  189.       return;
  190.     }
  192.     $ok = false;
  193.     if (is_link($targetDir))
  194.     {
  195.       if (readlink($targetDir) != $originDir)
  196.       {
  197.         unlink($targetDir);
  198.       }
  199.       else
  200.       {
  201.         $ok = true;
  202.       }
  203.     }
  205.     if (!$ok)
  206.     {
  207.       $this->logSection('link+', $targetDir);
  208.       symlink($originDir, $targetDir);
  209.     }
  210.   }
  212.   /**
  213.    * Creates a symbolic link using a relative path if possible.
  214.    *
  215.    * @param string $originDir      The origin directory path
  216.    * @param string $targetDir      The symbolic link name
  217.    * @param bool   $copyOnWindows  Whether to copy files if on windows
  218.    */
  219.   public function relativeSymlink($originDir, $targetDir, $copyOnWindows = false)
  220.   {
  221.     if (function_exists('symlink') || !$copyOnWindows)
  222.     {
  223.       $originDir = $this->calculateRelativeDir($targetDir, $originDir);
  224.     }
  225.     $this->symlink($originDir, $targetDir, $copyOnWindows);
  226.   }
  228.   /**
  229.    * Mirrors a directory to another.
  230.    *
  231.    * @param string   $originDir  The origin directory
  232.    * @param string   $targetDir  The target directory
  233.    * @param sfFinder $finder     An sfFinder instance
  234.    * @param array    $options    An array of options (see copy())
  235.    */
  236.   public function mirror($originDir, $targetDir, $finder, $options = array())
  237.   {
  238.     foreach ($finder->relative()->in($originDir) as $file)
  239.     {
  240.       if (is_dir($originDir.DIRECTORY_SEPARATOR.$file))
  241.       {
  242.         $this->mkdirs($targetDir.DIRECTORY_SEPARATOR.$file);
  243.       }
  244.       else if (is_file($originDir.DIRECTORY_SEPARATOR.$file))
  245.       {
  246.         $this->copy($originDir.DIRECTORY_SEPARATOR.$file, $targetDir.DIRECTORY_SEPARATOR.$file, $options);
  247.       }
  248.       else if (is_link($originDir.DIRECTORY_SEPARATOR.$file))
  249.       {
  250.         $this->symlink($originDir.DIRECTORY_SEPARATOR.$file, $targetDir.DIRECTORY_SEPARATOR.$file);
  251.       }
  252.       else
  253.       {
  254.         throw new sfException(sprintf('Unable to guess "%s" file type.', $file));
  255.       }
  256.     }
  257.   }
  259.   /**
  260.    * Executes a shell command.
  261.    *
  262.    * @param string $cmd            The command to execute on the shell
  263.    * @param array  $stdoutCallback A callback for stdout output
  264.    * @param array  $stderrCallback A callback for stderr output
  265.    *
  266.    * @return array An array composed of the content output and the error output
  267.    */
  268.   public function execute($cmd, $stdoutCallback = null, $stderrCallback = null)
  269.   {
  270.     $this->logSection('exec ', $cmd);
  272.     $descriptorspec = array(
  273.       1 => array('pipe', 'w'), // stdout
  274.       2 => array('pipe', 'w'), // stderr
  275.     );
  277.     $process = proc_open($cmd, $descriptorspec, $pipes);
  278.     if (!is_resource($process))
  279.     {
  280.       throw new RuntimeException('Unable to execute the command.');
  281.     }
  283.     stream_set_blocking($pipes[1], false);
  284.     stream_set_blocking($pipes[2], false);
  286.     $output = '';
  287.     $err = '';
  288.     while (!feof($pipes[1]))
  289.     {
  290.       foreach ($pipes as $key => $pipe)
  291.       {
  292.         if (!$line = fread($pipe, 128))
  293.         {
  294.           continue;
  295.         }
  297.         if (1 == $key)
  298.         {
  299.           // stdout
  300.           $output .= $line;
  301.           if ($stdoutCallback)
  302.           {
  303.             call_user_func($stdoutCallback, $line);
  304.           }
  305.         }
  306.         else
  307.         {
  308.           // stderr
  309.           $err .= $line;
  310.           if ($stderrCallback)
  311.           {
  312.             call_user_func($stderrCallback, $line);
  313.           }
  314.         }
  315.       }
  317.       sleep(0.1);
  318.     }
  320.     fclose($pipes[1]);
  321.     fclose($pipes[2]);
  323.     if (($return = proc_close($process)) > 0)
  324.     {
  325.       throw new RuntimeException('Problem executing command.', $return);
  326.     }
  328.     return array($output, $err);
  329.   }
  331.   /**
  332.    * Replaces tokens in an array of files.
  333.    *
  334.    * @param array  $files       An array of filenames
  335.    * @param string $beginToken  The begin token delimiter
  336.    * @param string $endToken    The end token delimiter
  337.    * @param array  $tokens      An array of token/value pairs
  338.    */
  339.   public function replaceTokens($files, $beginToken, $endToken, $tokens)
  340.   {
  341.     if (!is_array($files))
  342.     {
  343.       $files = array($files);
  344.     }
  346.     foreach ($files as $file)
  347.     {
  348.       $content = file_get_contents($file);
  349.       foreach ($tokens as $key => $value)
  350.       {
  351.         $content = str_replace($beginToken.$key.$endToken, $value, $content, $count);
  352.       }
  354.       $this->logSection('tokens', $file);
  356.       file_put_contents($file, $content);
  357.     }
  358.   }
  360.   /**
  361.    * Logs a message in a section.
  362.    *
  363.    * @param string $section  The section name
  364.    * @param string $message  The message
  365.    * @param int    $size     The maximum size of a line
  366.    */
  367.   protected function logSection($section, $message, $size = null)
  368.   {
  369.     if (!$this->dispatcher)
  370.     {
  371.       return;
  372.     }
  374.     $message = $this->formatter ? $this->formatter->formatSection($section, $message, $size) : $section.' '.$message."\n";
  376.     $this->dispatcher->notify(new sfEvent($this, 'command.log', array($message)));
  377.   }
  379.   /**
  380.    * Calculates the relative path from one to another directory.
  381.    *
  382.    * If the paths share no common path the absolute target dir is returned.
  383.    *
  384.    * @param string $from The directory from which to calculate the relative path
  385.    * @param string $to   The target directory
  386.    *
  387.    * @return string
  388.    */ 
  389.   protected function calculateRelativeDir($from, $to)
  390.   {
  391.     $from = $this->canonicalizePath($from);
  392.     $to = $this->canonicalizePath($to);
  394.     $commonLength = 0;
  395.     $minPathLength = min(strlen($from), strlen($to));
  397.     // count how many chars the strings have in common
  398.     for ($i = 0; $i < $minPathLength; $i++)
  399.     {
  400.       if ($from[$i] != $to[$i])
  401.       {
  402.         break;
  403.       }
  405.       if (DIRECTORY_SEPARATOR == $from[$i])
  406.       {
  407.         $commonLength = $i + 1;
  408.       }
  409.     }
  411.     if ($commonLength)
  412.     {
  413.       $levelUp = substr_count($from, DIRECTORY_SEPARATOR, $commonLength);
  415.       // up that many level
  416.       $relativeDir = str_repeat('..'.DIRECTORY_SEPARATOR, $levelUp);
  418.       // down the remaining $to path
  419.       $relativeDir .= substr($to, $commonLength);
  421.       return $relativeDir;
  422.     }
  424.     return $to;
  425.   }
  427.   /**
  428.    * @param string A filesystem path
  429.    *
  430.    * @return string
  431.    */
  432.   protected function canonicalizePath($path)
  433.   {
  434.     if (empty($path))
  435.     {
  436.       return '';
  437.     }
  439.     $out = array();
  440.     foreach (explode(DIRECTORY_SEPARATOR, $path) as $i => $fold)
  441.     {
  442.       if ('' == $fold || '.' == $fold)
  443.       {
  444.         continue;
  445.       }
  447.       if ('..' == $fold && $i > 0 && '..' != end($out))
  448.       {
  449.         array_pop($out);
  450.       }
  451.       else
  452.       {
  453.         $out[] = $fold;
  454.       }
  455.     }
  457.     $result  = DIRECTORY_SEPARATOR == $path[0] ? DIRECTORY_SEPARATOR : '';
  458.     $result .= implode(DIRECTORY_SEPARATOR, $out);
  459.     $result .= DIRECTORY_SEPARATOR == $path[strlen($path) - 1] ? DIRECTORY_SEPARATOR : '';
  461.     return $result;
  462.   }
  463. }
Debug toolbar