Source for file provider.php

Documentation is available at provider.php

  1. <?php
  2. /**
  3.  *  @package     FrameworkOnFramework
  4.  *  @subpackage  config
  5.  *  @copyright   Copyright (c)2010-2012 Nicholas K. Dionysopoulos
  6.  *  @license     GNU General Public License version 2, or later
  7.  */
  8.  
  9. defined('FOF_INCLUDED') or die();
  10.  
  11. /**
  12.  * Reads and parses the fof.xml file in the back-end of a FOF-powered component,
  13.  * provisioning the data to the rest of the FOF framework
  14.  *
  15.  * @package  FrameworkOnFramework
  16.  * @since    2.1
  17.  */
  18. class FOFConfigProvider
  19. {
  20.     /**
  21.      * Cache of FOF components' configuration variables
  22.      *
  23.      * @var array 
  24.      */
  25.     public static $configurations = array();
  26.  
  27.     /**
  28.      * Parses the configuration of the specified component
  29.      *
  30.      * @param   string   $component  The name of the component, e.g. com_foobar
  31.      * @param   boolean  $force      Force reload even if it's already parsed?
  32.      *
  33.      * @return  void 
  34.      */
  35.     public function parseComponent($component, $force = false)
  36.     {
  37.         if (!$force && isset(self::$configurations[$component]))
  38.         {
  39.             return;
  40.         }
  41.  
  42.         if (FOFPlatform::getInstance()->isCli())
  43.         {
  44.             $order = array('cli', 'backend');
  45.         }
  46.         elseif (FOFPlatform::getInstance()->isBackend())
  47.         {
  48.             $order = array('backend');
  49.         }
  50.         else
  51.         {
  52.             $order = array('frontend');
  53.         }
  54.  
  55.         $order[] = 'common';
  56.  
  57.         $order = array_reverse($order);
  58.         self::$configurations[$component] = array();
  59.  
  60.         foreach ($order as $area)
  61.         {
  62.             $config = $this->parseComponentArea($component, $area);
  63.             self::$configurations[$component] = array_merge_recursive(self::$configurations[$component], $config);
  64.         }
  65.     }
  66.  
  67.     /**
  68.      * Returns the value of a variable. Variables use a dot notation, e.g.
  69.      * view.config.whatever where the first part is the domain, the rest of the
  70.      * parts specify the path to the variable.
  71.      *
  72.      * @param   string  $variable  The variable name
  73.      * @param   mixed   $default   The default value, or null if not specified
  74.      *
  75.      * @return  mixed  The value of the variable
  76.      */
  77.     public function get($variable, $default = null)
  78.     {
  79.         static $domains = null;
  80.  
  81.         if (is_null($domains))
  82.         {
  83.             $domains = $this->getDomains();
  84.         }
  85.  
  86.         list($component, $domain, $var) = explode('.', $variable, 3);
  87.  
  88.         if (!isset(self::$configurations[$component]))
  89.         {
  90.             $this->parseComponent($component);
  91.         }
  92.  
  93.         if (!in_array($domain, $domains))
  94.         {
  95.             return $default;
  96.         }
  97.  
  98.         $class = 'FOFConfigDomain' . ucfirst($domain);
  99.         $o = new $class;
  100.  
  101.         return $o->get(self::$configurations[$component], $var, $default);
  102.     }
  103.  
  104.     /**
  105.      * Parses the configuration options of a specific component area
  106.      *
  107.      * @param   string  $component  Which component's cionfiguration to parse
  108.      * @param   string  $area       Which area to parse (frontend, backend, cli)
  109.      *
  110.      * @return  array  A hash array with the configuration data
  111.      */
  112.     protected function parseComponentArea($component, $area)
  113.     {
  114.         // Initialise the return array
  115.         $ret = array();
  116.  
  117.         // Get the folders of the component
  118.         $componentPaths = FOFPlatform::getInstance()->getComponentBaseDirs($component);
  119.  
  120.         // Check that the path exists
  121.         JLoader::import('joomla.filesystem.folder');
  122.         $path = $componentPaths['admin'];
  123.         $path = JPath::check($path);
  124.  
  125.         if (!JFolder::exists($path))
  126.         {
  127.             return $ret;
  128.         }
  129.  
  130.         // Read the filename if it exists
  131.         $filename = $path . '/fof.xml';
  132.         JLoader::import('joomla.filesystem.file');
  133.  
  134.         if (!JFile::exists($filename))
  135.         {
  136.             return $ret;
  137.         }
  138.  
  139.         $data = JFile::read($filename);
  140.  
  141.         // Load the XML data in a SimpleXMLElement object
  142.         $xml = simplexml_load_string($data);
  143.  
  144.         if (!($xml instanceof SimpleXMLElement))
  145.         {
  146.             return $ret;
  147.         }
  148.  
  149.         // Get this area's data
  150.         $areaData = $xml->xpath('//' . $area);
  151.  
  152.         if (empty($areaData))
  153.         {
  154.             return $ret;
  155.         }
  156.  
  157.         $xml = array_shift($areaData);
  158.  
  159.         // Parse individual configuration domains
  160.         $domains = $this->getDomains();
  161.  
  162.         foreach ($domains as $dom)
  163.         {
  164.             $class = 'FOFConfigDomain' . ucfirst($dom);
  165.  
  166.             if (class_exists($class, true))
  167.             {
  168.                 $o = new $class;
  169.                 $o->parseDomain($xml, $ret);
  170.             }
  171.         }
  172.  
  173.         // Finally, return the result
  174.         return $ret;
  175.     }
  176.  
  177.     /**
  178.      * Gets a list of the available configuration domain adapters
  179.      *
  180.      * @return  array  A list of the available domains
  181.      */
  182.     protected function getDomains()
  183.     {
  184.         static $domains = array();
  185.  
  186.         if (empty($domains))
  187.         {
  188.             JLoader::import('joomla.filesystem.folder');
  189.             $files = JFolder::files(__DIR__ . '/domain', '.php');
  190.  
  191.             if (!empty($files))
  192.             {
  193.                 foreach ($files as $file)
  194.                 {
  195.                     $domain = basename($file, '.php');
  196.  
  197.                     if ($domain == 'interface')
  198.                     {
  199.                         continue;
  200.                     }
  201.  
  202.                     $domain = preg_replace('/[^A-Za-z0-9]/', '', $domain);
  203.                     $domains[] = $domain;
  204.                 }
  205.  
  206.                 $domains = array_unique($domains);
  207.             }
  208.         }
  209.  
  210.         return $domains;
  211.     }
  212. }

Documentation generated on Tue, 19 Nov 2013 15:11:21 +0100 by phpDocumentor 1.4.3