1. sfBaseTask.class.php
  2. /**
 * Base class for all symfony tasks.
 *
 * @package    symfony
 * @subpackage task
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfBaseTask.class.php 24341 2009-11-24 15:01:58Z Kris.Wallsmith $
 */
  3. abstract class sfBaseTask extends sfCommandApplicationTask
  4. {
  5.   protected
  6.     $configuration = null,
  7.     $pluginManager = null;
  9.   /**
  10.    * @see sfTask
  11.    */
  12.   protected function doRun(sfCommandManager $commandManager, $options)
  13.   {
  14.     $event = $this->dispatcher->filter(new sfEvent($this, 'command.filter_options', array('command_manager' => $commandManager)), $options);
  15.     $options = $event->getReturnValue();
  17.     $this->process($commandManager, $options);
  19.     $event = new sfEvent($this, 'command.pre_command', array('arguments' => $commandManager->getArgumentValues(), 'options' => $commandManager->getOptionValues()));
  20.     $this->dispatcher->notifyUntil($event);
  21.     if ($event->isProcessed())
  22.     {
  23.       return $event->getReturnValue();
  24.     }
  26.     $this->checkProjectExists();
  28.     $requiresApplication = $commandManager->getArgumentSet()->hasArgument('application') || $commandManager->getOptionSet()->hasOption('application');
  29.     if (null === $this->configuration || ($requiresApplication && !$this->configuration instanceof sfApplicationConfiguration))
  30.     {
  31.       $application = $commandManager->getArgumentSet()->hasArgument('application') ? $commandManager->getArgumentValue('application') : ($commandManager->getOptionSet()->hasOption('application') ? $commandManager->getOptionValue('application') : null);
  32.       $env = $commandManager->getOptionSet()->hasOption('env') ? $commandManager->getOptionValue('env') : 'test';
  34.       if (true === $application)
  35.       {
  36.         $application = $this->getFirstApplication();
  38.         if ($commandManager->getOptionSet()->hasOption('application'))
  39.         {
  40.           $commandManager->setOption($commandManager->getOptionSet()->getOption('application'), $application);
  41.         }
  42.       }
  44.       $this->configuration = $this->createConfiguration($application, $env);
  45.     }
  47.     if (null !== $this->commandApplication && !$this->commandApplication->withTrace())
  48.     {
  49.       sfConfig::set('sf_logging_enabled', false);
  50.     }
  52.     $ret = $this->execute($commandManager->getArgumentValues(), $commandManager->getOptionValues());
  54.     $this->dispatcher->notify(new sfEvent($this, 'command.post_command'));
  56.     return $ret;
  57.   }
  59.   /**
  60.    * Sets the current task's configuration.
  61.    *
  62.    * @param sfProjectConfiguration $configuration
  63.    */
  64.   public function setConfiguration(sfProjectConfiguration $configuration = null)
  65.   {
  66.     $this->configuration = $configuration;
  67.   }
  69.   /**
  70.    * Returns the filesystem instance.
  71.    *
  72.    * @return sfFilesystem A sfFilesystem instance
  73.    */
  74.   public function getFilesystem()
  75.   {
  76.     if (!isset($this->filesystem))
  77.     {
  78.       if (null === $this->commandApplication || $this->commandApplication->isVerbose())
  79.       {
  80.         $this->filesystem = new sfFilesystem($this->dispatcher, $this->formatter);
  81.       }
  82.       else
  83.       {
  84.         $this->filesystem = new sfFilesystem();
  85.       }
  86.     }
  88.     return $this->filesystem;
  89.   }
  91.   /**
  92.    * Checks if the current directory is a symfony project directory.
  93.    *
  94.    * @return true if the current directory is a symfony project directory, false otherwise
  95.    */
  96.   public function checkProjectExists()
  97.   {
  98.     if (!file_exists('symfony'))
  99.     {
  100.       throw new sfException('You must be in a symfony project directory.');
  101.     }
  102.   }
  104.   /**
  105.    * Checks if an application exists.
  106.    *
  107.    * @param  string $app  The application name
  108.    *
  109.    * @return bool true if the application exists, false otherwise
  110.    */
  111.   public function checkAppExists($app)
  112.   {
  113.     if (!is_dir(sfConfig::get('sf_apps_dir').'/'.$app))
  114.     {
  115.       throw new sfException(sprintf('Application "%s" does not exist', $app));
  116.     }
  117.   }
  119.   /**
  120.    * Checks if a module exists.
  121.    *
  122.    * @param  string $app     The application name
  123.    * @param  string $module  The module name
  124.    *
  125.    * @return bool true if the module exists, false otherwise
  126.    */
  127.   public function checkModuleExists($app, $module)
  128.   {
  129.     if (!is_dir(sfConfig::get('sf_apps_dir').'/'.$app.'/modules/'.$module))
  130.     {
  131.       throw new sfException(sprintf('Module "%s/%s" does not exist.', $app, $module));
  132.     }
  133.   }
  135.   /**
  136.    * Creates a configuration object.
  137.    *
  138.    * @param string  $application The application name
  139.    * @param string  $env         The environment name
  140.    *
  141.    * @return sfProjectConfiguration A sfProjectConfiguration instance
  142.    */
  143.   protected function createConfiguration($application, $env)
  144.   {
  145.     if (null !== $application)
  146.     {
  147.       $this->checkAppExists($application);
  149.       require_once sfConfig::get('sf_config_dir').'/ProjectConfiguration.class.php';
  151.       $configuration = ProjectConfiguration::getApplicationConfiguration($application, $env, true, null, $this->dispatcher);
  152.     }
  153.     else
  154.     {
  155.       if (file_exists(sfConfig::get('sf_config_dir').'/ProjectConfiguration.class.php'))
  156.       {
  157.         require_once sfConfig::get('sf_config_dir').'/ProjectConfiguration.class.php';
  158.         $configuration = new ProjectConfiguration(null, $this->dispatcher);
  159.       }
  160.       else
  161.       {
  162.         $configuration = new sfProjectConfiguration(getcwd(), $this->dispatcher);
  163.       }
  165.       if (null !== $env)
  166.       {
  167.         sfConfig::set('sf_environment', $env);
  168.       }
  170.       $this->initializeAutoload($configuration);
  171.     }
  173.     return $configuration;
  174.   }
  176.   /**
  177.    * Returns the first application in apps.
  178.    *
  179.    * @return string The Application name
  180.    */
  181.   protected function getFirstApplication()
  182.   {
  183.     if (count($dirs = sfFinder::type('dir')->maxdepth(0)->follow_link()->relative()->in(sfConfig::get('sf_apps_dir'))))
  184.     {
  185.       return $dirs[0];
  186.     }
  188.     return null;
  189.   }
  191.   /**
  192.    * Reloads all autoloaders.
  193.    *
  194.    * This method should be called whenever a task generates new classes that
  195.    * are to be loaded by the symfony autoloader. It clears the autoloader
  196.    * cache for all applications and environments and the current execution.
  197.    *
  198.    * @see initializeAutoload()
  199.    */
  200.   protected function reloadAutoload()
  201.   {
  202.     $this->initializeAutoload($this->configuration, true);
  203.   }
  205.   /**
  206.    * Initializes autoloaders.
  207.    *
  208.    * @param sfProjectConfiguration $configuration The current project or application configuration
  209.    * @param boolean                $reload        If true, all autoloaders will be reloaded
  210.    */
  211.   protected function initializeAutoload(sfProjectConfiguration $configuration, $reload = false)
  212.   {
  213.     // sfAutoload
  214.     if ($reload)
  215.     {
  216.       $this->logSection('autoload', 'Resetting application autoloaders');
  218.       $finder = sfFinder::type('file')->name('*autoload.yml.php');
  219.       $this->getFilesystem()->remove($finder->in(sfConfig::get('sf_cache_dir')));
  220.       sfAutoload::getInstance()->reloadClasses(true);
  221.     }
  223.     // sfSimpleAutoload
  224.     if (!$configuration instanceof sfApplicationConfiguration)
  225.     {
  226.       // plugins
  227.       if ($reload)
  228.       {
  229.         foreach ($configuration->getPlugins() as $name)
  230.         {
  231.           $configuration->getPluginConfiguration($name)->initializeAutoload();
  232.         }
  233.       }
  235.       // project
  236.       $autoload = sfSimpleAutoload::getInstance(sfConfig::get('sf_cache_dir').'/project_autoload.cache');
  237.       $autoload->loadConfiguration(sfFinder::type('file')->name('autoload.yml')->in(array(
  238.         sfConfig::get('sf_symfony_lib_dir').'/config/config',
  239.         sfConfig::get('sf_config_dir'),
  240.       )));
  241.       $autoload->register();
  243.       if ($reload)
  244.       {
  245.         $this->logSection('autoload', 'Resetting CLI autoloader');
  246.         $autoload->reload();
  247.       }
  248.     }
  249.   }
  251.   /**
  252.    * Mirrors a directory structure inside the created project.
  253.    *
  254.    * @param string   $dir    The directory to mirror
  255.    * @param sfFinder $finder A sfFinder instance to use for the mirroring
  256.    */
  257.   protected function installDir($dir, $finder = null)
  258.   {
  259.     if (null === $finder)
  260.     {
  261.       $finder = sfFinder::type('any')->discard('.sf');
  262.     }
  264.     $this->getFilesystem()->mirror($dir, sfConfig::get('sf_root_dir'), $finder);
  265.   }
  267.   /**
  268.    * Replaces tokens in files contained in a given directory.
  269.    *
  270.    * If you don't pass a directory, it will replace in the config/ and lib/ directory.
  271.    *
  272.    * You can define global tokens by defining the $this->tokens property.
  273.    *
  274.    * @param array $dirs   An array of directory where to do the replacement
  275.    * @param array $tokens An array of tokens to use
  276.    */
  277.   protected function replaceTokens($dirs = array(), $tokens = array())
  278.   {
  279.     if (!$dirs)
  280.     {
  281.       $dirs = array(sfConfig::get('sf_config_dir'), sfConfig::get('sf_lib_dir'));
  282.     }
  284.     $tokens = array_merge(isset($this->tokens) ? $this->tokens : array(), $tokens);
  286.     $this->getFilesystem()->replaceTokens(sfFinder::type('file')->prune('vendor')->in($dirs), '##', '##', $tokens);
  287.   }
  289.   /**
  290.    * Reloads tasks.
  291.    *
  292.    * Useful when you install plugins with tasks and if you want to use them with the runTask() method.
  293.    */
  294.   protected function reloadTasks()
  295.   {
  296.     if (null === $this->commandApplication)
  297.     {
  298.       return;
  299.     }
  301.     $this->configuration = $this->createConfiguration(null, null);
  303.     $this->commandApplication->clearTasks();
  304.     $this->commandApplication->loadTasks($this->configuration);
  306.     $disabledPluginsRegex = sprintf('#^(%s)#', implode('|', array_diff($this->configuration->getAllPluginPaths(), $this->configuration->getPluginPaths())));
  307.     $tasks = array();
  308.     foreach (get_declared_classes() as $class)
  309.     {
  310.       $r = new Reflectionclass($class);
  311.       if ($r->isSubclassOf('sfTask') && !$r->isAbstract() && !preg_match($disabledPluginsRegex, $r->getFileName()))
  312.       {
  313.         $tasks[] = new $class($this->dispatcher, $this->formatter);
  314.       }
  315.     }
  317.     $this->commandApplication->registerTasks($tasks);
  318.   }
  320.   /**
  321.    * Enables a plugin in the ProjectConfiguration class.
  322.    *
  323.    * @param string $plugin The name of the plugin
  324.    */
  325.   protected function enablePlugin($plugin)
  326.   {
  327.     sfSymfonyPluginManager::enablePlugin($plugin, sfConfig::get('sf_config_dir'));
  328.   }
  330.   /**
  331.    * Disables a plugin in the ProjectConfiguration class.
  332.    *
  333.    * @param string $plugin The name of the plugin
  334.    */
  335.   protected function disablePlugin($plugin)
  336.   {
  337.     sfSymfonyPluginManager::disablePlugin($plugin, sfConfig::get('sf_config_dir'));
  338.   }
  340.   /**
  341.    * Returns a plugin manager instance.
  342.    *
  343.    * @return sfSymfonyPluginManager A sfSymfonyPluginManager instance
  344.    */
  345.   protected function getPluginManager()
  346.   {
  347.     if (null === $this->pluginManager)
  348.     {
  349.       $environment = new sfPearEnvironment($this->dispatcher, array(
  350.         'plugin_dir' => sfConfig::get('sf_plugins_dir'),
  351.         'cache_dir'  => sfConfig::get('sf_cache_dir').'/.pear',
  352.         'web_dir'    => sfConfig::get('sf_web_dir'),
  353.         'config_dir' => sfConfig::get('sf_config_dir'),
  354.       ));
  356.       $this->pluginManager = new sfSymfonyPluginManager($this->dispatcher, $environment);
  357.     }
  359.     return $this->pluginManager;
  360.   }
  362.   /**
  363.    * @see sfCommandApplicationTask
  364.    */
  365.   protected function createTask($name)
  366.   {
  367.     $task = parent::createTask($name);
  369.     if ($task instanceof sfBaseTask)
  370.     {
  371.       $task->setConfiguration($this->configuration);
  372.     }
  374.     return $task;
  375.   }
  376. }
Debug toolbar