1. sfContext.class.php
  2. /**
 * sfContext provides information about the current application context, such as
 * the module and action names and the module directory. References to the
 * main symfony instances are also provided.
 *
 * @package    symfony
 * @subpackage util
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfContext.class.php 23922 2009-11-14 14:58:38Z fabien $
 */
  3. class sfContext implements ArrayAccess
  4. {
  5.   protected
  6.     $dispatcher          = null,
  7.     $configuration       = null,
  8.     $mailerConfiguration = array(),
  9.     $factories           = array();
  11.   protected static
  12.     $instances = array(),
  13.     $current   = 'default';
  15.   /**
  16.    * Creates a new context instance.
  17.    *
  18.    * @param  sfApplicationConfiguration $configuration  An sfApplicationConfiguration instance
  19.    * @param  string                     $name           A name for this context (application name by default)
  20.    * @param  string                     $class          The context class to use (sfContext by default)
  21.    *
  22.    * @return sfContext                  An sfContext instance
  23.    */
  24.   static public function createInstance(sfApplicationConfiguration $configuration, $name = null, $class = __CLASS__)
  25.   {
  26.     if (null === $name)
  27.     {
  28.       $name = $configuration->getApplication();
  29.     }
  31.     self::$current = $name;
  33.     self::$instances[$name] = new $class();
  35.     if (!self::$instances[$name] instanceof sfContext)
  36.     {
  37.       throw new sfFactoryException(sprintf('Class "%s" is not of the type sfContext.', $class));
  38.     }
  40.     self::$instances[$name]->initialize($configuration);
  42.     return self::$instances[$name];
  43.   }
  45.   /**
  46.    * Initializes the current sfContext instance.
  47.    *
  48.    * @param sfApplicationConfiguration $configuration  An sfApplicationConfiguration instance
  49.    */
  50.   public function initialize(sfApplicationConfiguration $configuration)
  51.   {
  52.     $this->configuration = $configuration;
  53.     $this->dispatcher    = $configuration->getEventDispatcher();
  55.     try
  56.     {
  57.       $this->loadFactories();
  58.     }
  59.     catch (sfException $e)
  60.     {
  61.       $e->printStackTrace();
  62.     }
  63.     catch (Exception $e)
  64.     {
  65.       sfException::createFromException($e)->printStackTrace();
  66.     }
  68.     $this->dispatcher->connect('template.filter_parameters', array($this, 'filterTemplateParameters'));
  70.     // register our shutdown function
  71.     register_shutdown_function(array($this, 'shutdown'));
  72.   }
  74.   /**
  75.    * Retrieves the singleton instance of this class.
  76.    *
  77.    * @param  string    $name   The name of the sfContext to retrieve.
  78.    * @param  string    $class  The context class to use (sfContext by default)
  79.    *
  80.    * @return sfContext An sfContext implementation instance.
  81.    */
  82.   static public function getInstance($name = null, $class = __CLASS__)
  83.   {
  84.     if (null === $name)
  85.     {
  86.       $name = self::$current;
  87.     }
  89.     if (!isset(self::$instances[$name]))
  90.     {
  91.       throw new sfException(sprintf('The "%s" context does not exist.', $name));
  92.     }
  94.     return self::$instances[$name];
  95.   }
  97.   /**
  98.    * Checks to see if there has been a context created
  99.    *
  100.    * @param  string $name  The name of the sfContext to check for
  101.    *
  102.    * @return bool true is instanced, otherwise false
  103.    */
  105.   public static function hasInstance($name = null)
  106.   {
  107.     if (null === $name)
  108.     {
  109.       $name = self::$current;
  110.     }
  112.     return isset(self::$instances[$name]);
  113.   }
  115.   /**
  116.    * Loads the symfony factories.
  117.    */
  118.   public function loadFactories()
  119.   {
  120.     if (sfConfig::get('sf_use_database'))
  121.     {
  122.       // setup our database connections
  123.       $this->factories['databaseManager'] = new sfDatabaseManager($this->configuration, array('auto_shutdown' => false));
  124.     }
  126.     // create a new action stack
  127.     $this->factories['actionStack'] = new sfActionStack();
  129.     if (sfConfig::get('sf_debug') && sfConfig::get('sf_logging_enabled'))
  130.     {
  131.       $timer = sfTimerManager::getTimer('Factories');
  132.     }
  134.     // include the factories configuration
  135.     require($this->configuration->getConfigCache()->checkConfig('config/factories.yml'));
  137.     $this->dispatcher->notify(new sfEvent($this, 'context.load_factories'));
  139.     if (sfConfig::get('sf_debug') && sfConfig::get('sf_logging_enabled'))
  140.     {
  141.       $timer->addTime();
  142.     }
  143.   }
  145.   /**
  146.    * Dispatches the current request.
  147.    */
  148.   public function dispatch()
  149.   {
  150.     $this->getController()->dispatch();
  151.   }
  153.   /**
  154.    * Sets the current context to something else
  155.    *
  156.    * @param string $name  The name of the context to switch to
  157.    *
  158.    */
  159.   public static function switchTo($name)
  160.   {
  161.     if (!isset(self::$instances[$name]))
  162.     {
  163.       $currentConfiguration = sfContext::getInstance()->getConfiguration();
  164.       sfContext::createInstance(ProjectConfiguration::getApplicationConfiguration($name, $currentConfiguration->getEnvironment(), $currentConfiguration->isDebug()));
  165.     }
  167.     self::$current = $name;
  169.     sfContext::getInstance()->getConfiguration()->activate();
  170.   }
  172.   /**
  173.    * Returns the configuration instance.
  174.    *
  175.    * @return sfApplicationConfiguration  The current application configuration instance
  176.    */
  177.   public function getConfiguration()
  178.   {
  179.     return $this->configuration;
  180.   }
  182.   /**
  183.    * Retrieves the current event dispatcher.
  184.    *
  185.    * @return sfEventDispatcher An sfEventDispatcher instance
  186.    */
  187.   public function getEventDispatcher()
  188.   {
  189.     return $this->dispatcher;
  190.   }
  192.   /**
  193.    * Retrieve the action name for this context.
  194.    *
  195.    * @return string The currently executing action name, if one is set,
  196.    *                otherwise null.
  197.    */
  198.   public function getActionName()
  199.   {
  200.     // get the last action stack entry
  201.     if ($this->factories['actionStack'] && $lastEntry = $this->factories['actionStack']->getLastEntry())
  202.     {
  203.       return $lastEntry->getActionName();
  204.     }
  205.   }
  208.   /**
  209.    * Retrieve the ActionStack.
  210.    *
  211.    * @return sfActionStack the sfActionStack instance
  212.    */
  213.   public function getActionStack()
  214.   {
  215.     return $this->factories['actionStack'];
  216.   }
  218.   /**
  219.    * Retrieve the controller.
  220.    *
  221.    * @return sfController The current sfController implementation instance.
  222.    */
  223.    public function getController()
  224.    {
  225.      return isset($this->factories['controller']) ? $this->factories['controller'] : null;
  226.    }
  228.    /**
  229.     * Retrieves the mailer.
  230.     *
  231.     * @return sfMailer The current sfMailer implementation instance.
  232.     */
  233.    public function getMailer()
  234.    {
  235.      if (!isset($this->factories['mailer']))
  236.      {
  237.        $this->factories['mailer'] = new $this->mailerConfiguration['class']($this->dispatcher, $this->mailerConfiguration);
  238.      }
  240.      return $this->factories['mailer'];
  241.    }
  243.    public function setMailerConfiguration($configuration)
  244.    {
  245.      $this->mailerConfiguration = $configuration;
  246.    }
  248.    /**
  249.     * Retrieve the logger.
  250.     *
  251.     * @return sfLogger The current sfLogger implementation instance.
  252.     */
  253.    public function getLogger()
  254.    {
  255.      if (!isset($this->factories['logger']))
  256.      {
  257.        $this->factories['logger'] = new sfNoLogger($this->dispatcher);
  258.      }
  260.      return $this->factories['logger'];
  261.    }
  263.   /**
  264.    * Retrieve a database connection from the database manager.
  265.    *
  266.    * This is a shortcut to manually getting a connection from an existing
  267.    * database implementation instance.
  268.    *
  269.    * If the [sf_use_database] setting is off, this will return null.
  270.    *
  271.    * @param  name  $name  A database name.
  272.    *
  273.    * @return mixed A database instance.
  274.    *
  275.    * @throws sfDatabaseException if the requested database name does not exist.
  276.    */
  277.   public function getDatabaseConnection($name = 'default')
  278.   {
  279.     if (null !== $this->factories['databaseManager'])
  280.     {
  281.       return $this->factories['databaseManager']->getDatabase($name)->getConnection();
  282.     }
  284.     return null;
  285.   }
  287.   /**
  288.    * Retrieve the database manager.
  289.    *
  290.    * @return sfDatabaseManager The current sfDatabaseManager instance.
  291.    */
  292.   public function getDatabaseManager()
  293.   {
  294.     return isset($this->factories['databaseManager']) ? $this->factories['databaseManager'] : null;
  295.   }
  297.   /**
  298.    * Retrieve the module directory for this context.
  299.    *
  300.    * @return string An absolute filesystem path to the directory of the
  301.    *                currently executing module, if one is set, otherwise null.
  302.    */
  303.   public function getModuleDirectory()
  304.   {
  305.     // get the last action stack entry
  306.     if (isset($this->factories['actionStack']) && $lastEntry = $this->factories['actionStack']->getLastEntry())
  307.     {
  308.       return sfConfig::get('sf_app_module_dir').'/'.$lastEntry->getModuleName();
  309.     }
  310.   }
  312.   /**
  313.    * Retrieve the module name for this context.
  314.    *
  315.    * @return string The currently executing module name, if one is set,
  316.    *                otherwise null.
  317.    */
  318.   public function getModuleName()
  319.   {
  320.     // get the last action stack entry
  321.     if (isset($this->factories['actionStack']) && $lastEntry = $this->factories['actionStack']->getLastEntry())
  322.     {
  323.       return $lastEntry->getModuleName();
  324.     }
  325.   }
  327.   /**
  328.    * Retrieve the request.
  329.    *
  330.    * @return sfRequest The current sfRequest implementation instance.
  331.    */
  332.   public function getRequest()
  333.   {
  334.     return isset($this->factories['request']) ? $this->factories['request'] : null;
  335.   }
  337.   /**
  338.    * Retrieve the response.
  339.    *
  340.    * @return sfResponse The current sfResponse implementation instance.
  341.    */
  342.   public function getResponse()
  343.   {
  344.     return isset($this->factories['response']) ? $this->factories['response'] : null;
  345.   }
  347.   /**
  348.    * Set the response object.
  349.    *
  350.    * @param sfResponse $response  An sfResponse instance.
  351.    *
  352.    * @return void
  353.    */
  354.   public function setResponse($response)
  355.   {
  356.     $this->factories['response'] = $response;
  357.   }
  359.   /**
  360.    * Retrieve the storage.
  361.    *
  362.    * @return sfStorage The current sfStorage implementation instance.
  363.    */
  364.   public function getStorage()
  365.   {
  366.     return isset($this->factories['storage']) ? $this->factories['storage'] : null;
  367.   }
  369.   /**
  370.    * Retrieve the view cache manager
  371.    *
  372.    * @return sfViewCacheManager The current sfViewCacheManager implementation instance.
  373.    */
  374.   public function getViewCacheManager()
  375.   {
  376.     return isset($this->factories['viewCacheManager']) ? $this->factories['viewCacheManager'] : null;
  377.   }
  379.   /**
  380.    * Retrieve the i18n instance
  381.    *
  382.    * @return sfI18N The current sfI18N implementation instance.
  383.    */
  384.   public function getI18N()
  385.   {
  386.     if (!sfConfig::get('sf_i18n'))
  387.     {
  388.       throw new sfConfigurationException('You must enable i18n support in your settings.yml configuration file.');
  389.     }
  391.     return $this->factories['i18n'];
  392.   }
  394.   /**
  395.    * Retrieve the routing instance.
  396.    *
  397.    * @return sfRouting The current sfRouting implementation instance.
  398.    */
  399.   public function getRouting()
  400.   {
  401.     return isset($this->factories['routing']) ? $this->factories['routing'] : null;
  402.   }
  404.   /**
  405.    * Retrieve the user.
  406.    *
  407.    * @return sfUser The current sfUser implementation instance.
  408.    */
  409.   public function getUser()
  410.   {
  411.     return isset($this->factories['user']) ? $this->factories['user'] : null;
  412.   }
  414.   /**
  415.    * Returns the configuration cache.
  416.    *
  417.    * @return sfConfigCache A sfConfigCache instance
  418.    */
  419.   public function getConfigCache()
  420.   {
  421.     return $this->configuration->getConfigCache();
  422.   }
  423.   
  424.   /**
  425.    * Returns true if the context object exists (implements the ArrayAccess interface).
  426.    *
  427.    * @param  string $name The name of the context object
  428.    *
  429.    * @return Boolean true if the context object exists, false otherwise
  430.    */
  431.   public function offsetExists($name)
  432.   {
  433.     return $this->has($name);
  434.   }
  436.   /**
  437.    * Returns the context object associated with the name (implements the ArrayAccess interface).
  438.    *
  439.    * @param  string $name  The offset of the value to get
  440.    *
  441.    * @return mixed The context object if exists, null otherwise
  442.    */
  443.   public function offsetGet($name)
  444.   {
  445.     return $this->get($name);
  446.   }
  448.   /**
  449.    * Sets the context object associated with the offset (implements the ArrayAccess interface).
  450.    *
  451.    * @param string $offset The parameter name
  452.    * @param string $value The parameter value
  453.    */
  454.   public function offsetSet($offset, $value)
  455.   {
  456.     $this->set($offset, $value);
  457.   }
  459.   /**
  460.    * Unsets the context object associated with the offset (implements the ArrayAccess interface).
  461.    *
  462.    * @param string $offset The parameter name
  463.    */
  464.   public function offsetUnset($offset)
  465.   {
  466.     unset($this->factories[$offset]);
  467.   }
  469.   /**
  470.    * Gets an object from the current context.
  471.    *
  472.    * @param  string $name  The name of the object to retrieve
  473.    *
  474.    * @return object The object associated with the given name
  475.    */
  476.   public function get($name)
  477.   {
  478.     if (!$this->has($name))
  479.     {
  480.       throw new sfException(sprintf('The "%s" object does not exist in the current context.', $name));
  481.     }
  483.     return $this->factories[$name];
  484.   }
  486.   /**
  487.    * Puts an object in the current context.
  488.    *
  489.    * @param string $name    The name of the object to store
  490.    * @param object $object  The object to store
  491.    */
  492.   public function set($name, $object)
  493.   {
  494.     $this->factories[$name] = $object;
  495.   }
  497.   /**
  498.    * Returns true if an object is currently stored in the current context with the given name, false otherwise.
  499.    *
  500.    * @param  string $name  The object name
  501.    *
  502.    * @return bool true if the object is not null, false otherwise
  503.    */
  504.   public function has($name)
  505.   {
  506.     return isset($this->factories[$name]);
  507.   }
  509.   /**
  510.    * Listens to the template.filter_parameters event.
  511.    *
  512.    * @param  sfEvent $event       An sfEvent instance
  513.    * @param  array   $parameters  An array of template parameters to filter
  514.    *
  515.    * @return array   The filtered parameters array
  516.    */
  517.   public function filterTemplateParameters(sfEvent $event, $parameters)
  518.   {
  519.     $parameters['sf_context']  = $this;
  520.     $parameters['sf_request']  = $this->factories['request'];
  521.     $parameters['sf_params']   = $this->factories['request']->getParameterHolder();
  522.     $parameters['sf_response'] = $this->factories['response'];
  523.     $parameters['sf_user']     = $this->factories['user'];
  525.     return $parameters;
  526.   }
  527.   
  528.   /**
  529.    * Calls methods defined via sfEventDispatcher.
  530.    *
  531.    * If a method cannot be found via sfEventDispatcher, the method name will
  532.    * be parsed to magically handle getMyFactory() and setMyFactory() methods.
  533.    *
  534.    * @param  string $method     The method name
  535.    * @param  array  $arguments  The method arguments
  536.    *
  537.    * @return mixed The returned value of the called method
  538.    *
  539.    * @throws <b>sfException</b> if call fails
  540.    */
  541.   public function __call($method, $arguments)
  542.   {
  543.     $event = $this->dispatcher->notifyUntil(new sfEvent($this, 'context.method_not_found', array('method' => $method, 'arguments' => $arguments)));
  544.     if (!$event->isProcessed())
  545.     {
  546.       $verb = substr($method, 0, 3); // get | set
  547.       $factory = strtolower(substr($method, 3)); // factory name
  549.       if ('get' == $verb && $this->has($factory))
  550.       {
  551.         return $this->factories[$factory];
  552.       }
  553.       else if ('set' == $verb && isset($arguments[0]))
  554.       {
  555.         return $this->set($factory, $arguments[0]);
  556.       }
  558.       throw new sfException(sprintf('Call to undefined method %s::%s.', get_class($this), $method));
  559.     }
  561.     return $event->getReturnValue();
  562.   }
  564.   /**
  565.    * Execute the shutdown procedure.
  566.    *
  567.    * @return void
  568.    */
  569.   public function shutdown()
  570.   {
  571.     // shutdown all factories
  572.     if($this->has('user'))
  573.     {
  574.       $this->getUser()->shutdown();
  575.       $this->getStorage()->shutdown();
  576.     }
  578.     if ($this->has('routing'))
  579.     {
  580.     	$this->getRouting()->shutdown();
  581.     }
  583.     if (sfConfig::get('sf_use_database'))
  584.     {
  585.       $this->getDatabaseManager()->shutdown();
  586.     }
  588.     if (sfConfig::get('sf_logging_enabled'))
  589.     {
  590.       $this->getLogger()->shutdown();
  591.     }
  592.   }
  593. }
Debug toolbar