1. sfPluginConfiguration.class.php
  2. /**
 * sfPluginConfiguration represents a configuration for a symfony plugin.
 * 
 * @package    symfony
 * @subpackage config
 * @author     Kris Wallsmith 
 * @version    SVN: $Id: sfPluginConfiguration.class.php 23822 2009-11-12 15:13:48Z Kris.Wallsmith $
 */
  3. abstract class sfPluginConfiguration
  4. {
  5.   protected
  6.     $configuration = null,
  7.     $dispatcher    = null,
  8.     $name          = null,
  9.     $rootDir       = null;
  11.   /**
  12.    * Constructor.
  13.    * 
  14.    * @param sfProjectConfiguration $configuration The project configuration
  15.    * @param string                 $rootDir       The plugin root directory
  16.    * @param string                 $name          The plugin name
  17.    */
  18.   public function __construct(sfProjectConfiguration $configuration, $rootDir = null, $name = null)
  19.   {
  20.     $this->configuration = $configuration;
  21.     $this->dispatcher = $configuration->getEventDispatcher();
  22.     $this->rootDir = null === $rootDir ? $this->guessRootDir() : realpath($rootDir);
  23.     $this->name = null === $name ? $this->guessName() : $name;
  25.     $this->setup();
  26.     $this->configure();
  28.     if (!$this->configuration instanceof sfApplicationConfiguration)
  29.     {
  30.       $this->initializeAutoload();
  31.       $this->initialize();
  32.     }
  33.   }
  35.   /**
  36.    * Sets up the plugin.
  37.    * 
  38.    * This method can be used when creating a base plugin configuration class for other plugins to extend.
  39.    */
  40.   public function setup()
  41.   {
  42.   }
  44.   /**
  45.    * Configures the plugin.
  46.    * 
  47.    * This method is called before the plugin's classes have been added to sfAutoload.
  48.    */
  49.   public function configure()
  50.   {
  51.   }
  53.   /**
  54.    * Initializes the plugin.
  55.    * 
  56.    * This method is called after the plugin's classes have been added to sfAutoload.
  57.    * 
  58.    * @return boolean|null If false sfApplicationConfiguration will look for a config.php (maintains BC with symfony < 1.2)
  59.    */
  60.   public function initialize()
  61.   {
  62.   }
  64.   /**
  65.    * Returns the plugin root directory.
  66.    * 
  67.    * @return string
  68.    */
  69.   public function getRootDir()
  70.   {
  71.     return $this->rootDir;
  72.   }
  74.   /**
  75.    * Returns the plugin name.
  76.    * 
  77.    * @return string
  78.    */
  79.   public function getName()
  80.   {
  81.     return $this->name;
  82.   }
  84.   /**
  85.    * Initializes autoloading for the plugin.
  86.    * 
  87.    * This method is called when a plugin is initialized in a project
  88.    * configuration. Otherwise, autoload is handled in
  89.    * {@link sfApplicationConfiguration} using {@link sfAutoload}.
  90.    * 
  91.    * @see sfSimpleAutoload
  92.    */
  93.   public function initializeAutoload()
  94.   {
  95.     $autoload = sfSimpleAutoload::getInstance(sfConfig::get('sf_cache_dir').'/project_autoload.cache');
  97.     if (is_readable($file = $this->rootDir.'/config/autoload.yml'))
  98.     {
  99.       $this->configuration->getEventDispatcher()->connect('autoload.filter_config', array($this, 'filterAutoloadConfig'));
  100.       $autoload->loadConfiguration(array($file));
  101.       $this->configuration->getEventDispatcher()->disconnect('autoload.filter_config', array($this, 'filterAutoloadConfig'));
  102.     }
  103.     else
  104.     {
  105.       $autoload->addDirectory($this->rootDir.'/lib');
  106.     }
  108.     $autoload->register();
  109.   }
  111.   /**
  112.    * Filters sfAutoload configuration values.
  113.    * 
  114.    * @param sfEvent $event  
  115.    * @param array   $config 
  116.    * 
  117.    * @return array
  118.    */
  119.   public function filterAutoloadConfig(sfEvent $event, array $config)
  120.   {
  121.     // use array_merge so config is added to the front of the autoload array
  122.     if (!isset($config['autoload'][$this->name.'_lib']))
  123.     {
  124.       $config['autoload'] = array_merge(array(
  125.         $this->name.'_lib' => array(
  126.           'path'      => $this->rootDir.'/lib',
  127.           'recursive' => true,
  128.         ),
  129.       ), $config['autoload']);
  130.     }
  132.     if (!isset($config['autoload'][$this->name.'_module_libs']))
  133.     {
  134.       $config['autoload'] = array_merge(array(
  135.         $this->name.'_module_libs' => array(
  136.           'path'      => $this->rootDir.'/modules/*/lib',
  137.           'recursive' => true,
  138.           'prefix'    => 1,
  139.         ),
  140.       ), $config['autoload']);
  141.     }
  143.     return $config;
  144.   }
  146.   /**
  147.    * Connects the current plugin's tests to the "test:*" tasks.
  148.    */
  149.   public function connectTests()
  150.   {
  151.     $this->dispatcher->connect('task.test.filter_test_files', array($this, 'filterTestFiles'));
  152.   }
  154.   /**
  155.    * Listens for the "task.test.filter_test_files" event and adds tests from the current plugin.
  156.    * 
  157.    * @param  sfEvent $event
  158.    * @param  array   $files
  159.    * 
  160.    * @return array An array of files with the appropriate tests from the current plugin merged in
  161.    */
  162.   public function filterTestFiles(sfEvent $event, $files)
  163.   {
  164.     $task = $event->getSubject();
  166.     if ($task instanceof sfTestAllTask)
  167.     {
  168.       $directory = $this->rootDir.'/test';
  169.       $names = array();
  170.     }
  171.     else if ($task instanceof sfTestFunctionalTask)
  172.     {
  173.       $directory = $this->rootDir.'/test/functional';
  174.       $names = $event['arguments']['controller'];
  175.     }
  176.     else if ($task instanceof sfTestUnitTask)
  177.     {
  178.       $directory = $this->rootDir.'/test/unit';
  179.       $names = $event['arguments']['name'];
  180.     }
  182.     if (!count($names))
  183.     {
  184.       $names = array('*');
  185.     }
  187.     foreach ($names as $name)
  188.     {
  189.       $finder = sfFinder::type('file')->follow_link()->name(basename($name).'Test.php');
  190.       $files = array_merge($files, $finder->in($directory.'/'.dirname($name)));
  191.     }
  193.     return array_unique($files);
  194.   }
  196.   /**
  197.    * Guesses the plugin root directory.
  198.    * 
  199.    * @return string
  200.    */
  201.   protected function guessRootDir()
  202.   {
  203.     $r = new ReflectionClass(get_class($this));
  204.     return realpath(dirname($r->getFilename()).'/..');
  205.   }
  207.   /**
  208.    * Guesses the plugin name.
  209.    * 
  210.    * @return string
  211.    */
  212.   protected function guessName()
  213.   {
  214.     return substr(get_class($this), 0, -13);
  215.   }
  216. }
Debug toolbar