1. sfClassManipulator.class.php
  2. /**
 * sfClassManipulator manipulates class code.
 *
 * @package    symfony
 * @subpackage util
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfClassManipulator.class.php 25063 2009-12-08 06:02:07Z Kris.Wallsmith $
 */
  3. class sfClassManipulator
  4. {
  5.   static protected $signatureTokens = array(
  6.     T_FINAL,
  7.     T_ABSTRACT,
  8.     T_STATIC,
  9.     T_PUBLIC,
  10.     T_PROTECTED,
  11.     T_PRIVATE,
  12.     T_FUNCTION,
  13.   );
  15.   protected $code = '', $file = false;
  17.   /**
  18.    * Constructor.
  19.    *
  20.    * @param string $code The code to manipulate
  21.    */
  22.   public function __construct($code)
  23.   {
  24.     $this->code = $code;
  25.   }
  27.   /**
  28.    * Creates a manipulator object from a file.
  29.    *
  30.    * @param string $file A file name
  31.    *
  32.    * @return sfClassManipulator A sfClassManipulator instance
  33.    */
  34.   static public function fromFile($file)
  35.   {
  36.     $manipulator = new self(file_get_contents($file));
  37.     $manipulator->setFile($file);
  39.     return $manipulator;
  40.   }
  42.   /**
  43.    * Saves the code back to the associated file.
  44.    *
  45.    * This only works if you have bound the instance with a file with the setFile() method.
  46.    *
  47.    * @throw LogicException if no file is associated with the instance
  48.    */
  49.   public function save()
  50.   {
  51.     if (!$this->file)
  52.     {
  53.       throw new LogicException('Unable to save the code as no file has been provided.');
  54.     }
  56.     file_put_contents($this->file, $this->code);
  57.   }
  59.   /**
  60.    * Gets the modified code.
  61.    *
  62.    * @return string The modified code
  63.    */
  64.   public function getCode()
  65.   {
  66.     return $this->code;
  67.   }
  69.   /**
  70.    * Gets the associated file.
  71.    *
  72.    * @return string The associated file
  73.    */
  74.   public function getFile()
  75.   {
  76.     return $this->file;
  77.   }
  79.   /**
  80.    * Sets the file associated with this instance.
  81.    *
  82.    * @param string A file name
  83.    */
  84.   public function setFile($file)
  85.   {
  86.     $this->file = $file;
  87.   }
  89.   /**
  90.    * Wraps an existing method with some code.
  91.    *
  92.    * @param string $method     The method name to change
  93.    * @param string $topCode    The code to add at the top of the method
  94.    * @param string $bottomCode The code to add at the bottom of the method
  95.    */
  96.   public function wrapMethod($method, $topCode = '', $bottomCode = '')
  97.   {
  98.     $code = '';
  99.     $insideSetup = -1;
  100.     $parens = 0;
  101.     foreach (token_get_all($this->code) as $token)
  102.     {
  103.       if (isset($token[1]))
  104.       {
  105.         if (-1 == $insideSetup && T_FUNCTION == $token[0])
  106.         {
  107.           $insideSetup = 0;
  108.         }
  109.         elseif (0 == $insideSetup && T_STRING == $token[0])
  110.         {
  111.           $insideSetup = $method == $token[1] ? 1 : -1;
  112.         }
  114.         $code .= $token[1];
  115.       }
  116.       else
  117.       {
  118.         if (1 == $insideSetup && '{' == $token)
  119.         {
  120.           if (!$parens)
  121.           {
  122.             $code .= $topCode ? $token.PHP_EOL.'    '.$topCode : $token;
  123.           }
  124.           else
  125.           {
  126.             $code .= $token;
  127.           }
  129.           ++$parens;
  130.         }
  131.         elseif (1 == $insideSetup && '}' == $token)
  132.         {
  133.           --$parens;
  135.           if (!$parens)
  136.           {
  137.             $insideSetup = -1;
  139.             $code .= $bottomCode ? '  '.$bottomCode.PHP_EOL.'  '.$token : $token;
  140.           }
  141.           else
  142.           {
  143.             $code .= $token;
  144.           }
  145.         }
  146.         else
  147.         {
  148.           $code .= $token;
  149.         }
  150.       }
  151.     }
  153.     return $this->code = $code;
  154.   }
  156.   /**
  157.    * Filters each line of the given method through a callable.
  158.    * 
  159.    * @param string $method   The method name
  160.    * @param mixed  $callable A PHP callable that accepts and returns one line of PHP code
  161.    */
  162.   public function filterMethod($method, $callable)
  163.   {
  164.     $line = '';
  165.     $code = '';
  166.     $insideSetup = -1;
  167.     $parens = 0;
  168.     $break = false;
  170.     $tokens = token_get_all($this->code);
  171.     for ($i = 0; $i < count($tokens); $i++)
  172.     {
  173.       $token = $tokens[$i];
  175.       if (is_array($token))
  176.       {
  177.         $line .= $token[1];
  179.         if (-1 == $insideSetup && T_FUNCTION == $token[0])
  180.         {
  181.           $insideSetup = 0;
  182.         }
  183.         elseif (0 == $insideSetup && T_STRING == $token[0])
  184.         {
  185.           $insideSetup = $method == $token[1] ? 1 : -1;
  186.         }
  187.       }
  188.       else
  189.       {
  190.         if (1 == $insideSetup && '{' == $token)
  191.         {
  192.           ++$parens;
  193.         }
  194.         elseif (1 == $insideSetup && '}' == $token)
  195.         {
  196.           --$parens;
  198.           if (!$parens)
  199.           {
  200.             $break = true;
  201.           }
  202.         }
  204.         $line .= $token;
  205.       }
  207.       $lines = preg_split('/(\r?\n)/', $line, null, PREG_SPLIT_DELIM_CAPTURE);
  208.       if (count($lines) > 1 || $break)
  209.       {
  210.         $line = $break ? '' : array_pop($lines);
  211.         foreach (array_chunk($lines, 2) as $chunk)
  212.         {
  213.           list($l, $eol) = array_pad($chunk, 2, '');
  215.           if (1 == $insideSetup)
  216.           {
  217.             list($before, $setup) = $this->splitSetup($l);
  218.             $code .= $before;
  219.             $code .= call_user_func($callable, $setup.$eol);
  220.           }
  221.           else
  222.           {
  223.             $code .= $l.$eol;
  224.           }
  225.         }
  226.       }
  228.       if ($break)
  229.       {
  230.         $insideSetup = -1;
  231.         $break = false;
  232.       }
  233.     }
  235.     if ($line)
  236.     {
  237.       $code .= $line;
  238.     }
  240.     return $this->code = $code;
  241.   }
  243.   protected function splitSetup($line)
  244.   {
  245.     $before = '';
  246.     $setup = '';
  248.     if ($line)
  249.     {
  250.       if (false === stripos($line, '<?php'))
  251.       {
  252.         // add a function so we can accurately slice
  253.         $tokens = token_get_all('<?php function'.$line);
  254.         $tokens = array_slice($tokens, 2);
  255.       }
  256.       else
  257.       {
  258.         $tokens = token_get_all($line);
  259.       }
  261.       // we're in reverse
  262.       $inSignature = false;
  263.       while ($token = array_pop($tokens))
  264.       {
  265.         $value = $this->getTokenValue($token);
  266.         if (is_array($token) && in_array($token[0], self::$signatureTokens))
  267.         {
  268.           $inSignature = true;
  269.         }
  270.         elseif ($inSignature && !preg_match('/\s+/', $value))
  271.         {
  272.           // clean up
  273.           preg_match('/^\s*/', $setup, $match);
  274.           $before = implode('', array_map(array($this, 'getTokenValue'), $tokens)).$value.$match[0];
  275.           $setup = substr($setup, strlen($match[0]));
  277.           return array($before, $setup);
  278.         }
  280.         $setup = $value.$setup;
  281.       }
  282.     }
  284.     return array($before, $setup);
  285.   }
  287.   /**
  288.    * Returns a token's string value.
  289.    *
  290.    * @param array|string $token
  291.    *
  292.    * @return string
  293.    */
  294.   protected function getTokenValue($token)
  295.   {
  296.     return is_array($token) ? $token[1] : $token;
  297.   }
  298. }
Debug toolbar