1. sfPearEnvironment.class.php
  2. /**
 * sfPearEnvironment represents a PEAR environment.
 *
 * @package    symfony
 * @subpackage plugin
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfPearEnvironment.class.php 17450 2009-04-20 17:37:49Z fabien $
 */
  3. class sfPearEnvironment
  4. {
  5.   protected
  6.     $dispatcher = null,
  7.     $config     = null,
  8.     $registry   = null,
  9.     $rest       = null,
  10.     $frontend   = null,
  11.     $options    = array();
  13.   /**
  14.    * Constructs a new sfPluginManager.
  15.    *
  16.    * @param sfEventDispatcher $dispatcher   An event dispatcher instance
  17.    * @param array             $options      An array of options
  18.    */
  19.   public function __construct(sfEventDispatcher $dispatcher, $options)
  20.   {
  21.     $this->initialize($dispatcher, $options);
  22.   }
  24.   /**
  25.    * Initializes this sfPluginManager instance.
  26.    *
  27.    * Available options:
  28.    *
  29.    * * plugin_dir:            The directory where to put plugins
  30.    * * cache_dir:             The local PEAR cache directory
  31.    * * rest_base_class:       The base class for REST calls (default to sfPearRest)
  32.    *                          (mainly used for testing)
  33.    * * downloader_base_class: The base class for downloads (default to sfPearDownloader)
  34.    *                          (mainly used for testing)
  35.    *
  36.    * @param sfEventDispatcher $dispatcher   An event dispatcher instance
  37.    * @param array             $options      An array of options
  38.    */
  39.   public function initialize(sfEventDispatcher $dispatcher, $options = array())
  40.   {
  41.     $this->dispatcher = $dispatcher;
  43.     // initialize options
  44.     if (!isset($options['plugin_dir']))
  45.     {
  46.       throw new sfConfigurationException('You must provide a "plugin_dir" option.');
  47.     }
  49.     if (!isset($options['cache_dir']))
  50.     {
  51.       throw new sfConfigurationException('You must provide a "cache_dir" option.');
  52.     }
  54.     if (!is_dir($options['cache_dir']))
  55.     {
  56.       mkdir($options['cache_dir'], 0777, true);
  57.     }
  59.     if (!isset($options['rest_base_class']))
  60.     {
  61.       $options['rest_base_class'] = 'sfPearRest';
  62.     }
  64.     if (!isset($options['downloader_base_class']))
  65.     {
  66.       $options['downloader_base_class'] = 'sfPearDownloader';
  67.     }
  69.     $this->options = $options;
  71.     // initialize some PEAR objects
  72.     $this->initializeConfiguration($options['plugin_dir'], $options['cache_dir']);
  73.     $this->initializeRegistry();
  74.     $this->initializeFrontend();
  76.     // initializes the REST object
  77.     $this->rest = new sfPearRestPlugin($this->config, array('base_class' => $options['rest_base_class']));
  78.     $this->rest->setChannel($this->config->get('default_channel'));
  79.   }
  81.   /**
  82.    * Returns a configuration value.
  83.    *
  84.    * @param  string $name The configuration name
  85.    *
  86.    * @return mixed  The configuration value
  87.    */
  88.   public function getOption($name)
  89.   {
  90.     return isset($this->options[$name]) ? $this->options[$name] : null;
  91.   }
  93.   /**
  94.    * Returns whether configuration name exists.
  95.    *
  96.    * @param  string $name The configuration name
  97.    *
  98.    * @return boolean True if configuration name exists
  99.    */
  100.   public function hasOption($name)
  101.   {
  102.     return isset($this->options[$name]);
  103.   }
  105.   /**
  106.    * Sets a configuration value.
  107.    *
  108.    * @param string $name  The configuration name
  109.    * @param mixed  $value The configuration value
  110.    */
  111.   public function setOption($name, $value)
  112.   {
  113.     $this->options[$name] = $value;
  114.   }
  116.   /**
  117.    * Returns the PEAR Rest instance.
  118.    *
  119.    * @return object The PEAR Rest instance
  120.    */
  121.   public function getRest()
  122.   {
  123.     return $this->rest;
  124.   }
  126.   /**
  127.    * Returns the PEAR Config instance.
  128.    *
  129.    * @return object The PEAR Config instance
  130.    */
  131.   public function getConfig()
  132.   {
  133.     return $this->config;
  134.   }
  136.   /**
  137.    * Returns the PEAR Frontend instance.
  138.    *
  139.    * @return object The PEAR Frontend instance
  140.    */
  141.   public function getFrontend()
  142.   {
  143.     return $this->frontend;
  144.   }
  146.   /**
  147.    * Returns the PEAR Registry instance.
  148.    *
  149.    * @return object The PEAR Registry instance
  150.    */
  151.   public function getRegistry()
  152.   {
  153.     return $this->registry;
  154.   }
  156.   /**
  157.    * Registers a PEAR channel.
  158.    *
  159.    * @param string  $channel    The channel name
  160.    * @param Boolean $isDefault  true if this is the default PEAR channel, false otherwise
  161.    */
  162.   public function registerChannel($channel, $isDefault = false)
  163.   {
  164.     $this->config->set('auto_discover', true);
  166.     if (!$this->registry->channelExists($channel, true))
  167.     {
  168.       $class = $this->options['downloader_base_class'];
  169.       $downloader = new $class($this->frontend, array(), $this->config);
  170.       if (!$downloader->discover($channel))
  171.       {
  172.         throw new sfPluginException(sprintf('Unable to register channel "%s"', $channel));
  173.       }
  174.     }
  176.     if ($isDefault)
  177.     {
  178.       $this->config->set('default_channel', $channel);
  179.       $this->rest->setChannel($channel);
  180.     }
  181.   }
  183.   /**
  184.    * Initializes the PEAR Frontend instance.
  185.    */
  186.   protected function initializeFrontend()
  187.   {
  188.     $this->frontend = PEAR_Frontend::singleton('sfPearFrontendPlugin');
  189.     if (PEAR::isError($this->frontend))
  190.     {
  191.       throw new sfPluginException(sprintf('Unable to initialize PEAR Frontend object: %s', $this->frontend->getMessage()));
  192.     }
  194.     $this->frontend->setEventDispatcher($this->dispatcher);
  195.   }
  197.   /**
  198.    * Initializes the PEAR Registry instance.
  199.    */
  200.   protected function initializeRegistry()
  201.   {
  202.     $this->registry = $this->config->getRegistry();
  203.     if (PEAR::isError($this->registry))
  204.     {
  205.       throw new sfPluginException(sprintf('Unable to initialize PEAR registry: %s', $this->registry->getMessage()));
  206.     }
  207.   }
  209.   /**
  210.    * Registers the PEAR Configuration instance.
  211.    *
  212.    * @param string $pluginDir   The plugin path
  213.    * @param string $cacheDir    The cache path
  214.    */
  215.   public function initializeConfiguration($pluginDir, $cacheDir)
  216.   {
  217.     $this->config = $GLOBALS['_PEAR_Config_instance'] = new sfPearConfig();
  219.     // change the configuration for use
  220.     $this->config->set('php_dir',  $pluginDir);
  221.     $this->config->set('data_dir', $pluginDir);
  222.     $this->config->set('test_dir', $pluginDir);
  223.     $this->config->set('doc_dir',  $pluginDir);
  224.     $this->config->set('bin_dir',  $pluginDir);
  226.     if($this->hasOption('preferred_state'))
  227.     {
  228.       $this->config->set('preferred_state', $this->getOption('preferred_state'));
  229.     }
  231.     // change the PEAR temp dirs
  232.     $this->config->set('cache_dir',    $cacheDir);
  233.     $this->config->set('download_dir', $cacheDir);
  234.     $this->config->set('temp_dir',     $cacheDir);
  236.     $this->config->set('verbose', 1);
  237.   }
  238. }
Debug toolbar