File fof/config/provider.php | Joomla! Framework TM

  1 <?php
  2 /**
  3  *  @package     FrameworkOnFramework
  4  *  @subpackage  config
  5  * @copyright   Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba Ltd. All rights reserved.
  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         $filesystem     = FOFPlatform::getInstance()->getIntegrationObject('filesystem');
120 
121         // Check that the path exists
122         $path = $componentPaths['admin'];
123         $path = $filesystem->pathCheck($path);
124 
125         if (!$filesystem->folderExists($path))
126         {
127             return $ret;
128         }
129 
130         // Read the filename if it exists
131         $filename = $path . '/fof.xml';
132 
133         if (!$filesystem->fileExists($filename))
134         {
135             return $ret;
136         }
137 
138         $data = file_get_contents($filename);
139 
140         // Load the XML data in a SimpleXMLElement object
141         $xml = simplexml_load_string($data);
142 
143         if (!($xml instanceof SimpleXMLElement))
144         {
145             return $ret;
146         }
147 
148         // Get this area's data
149         $areaData = $xml->xpath('//' . $area);
150 
151         if (empty($areaData))
152         {
153             return $ret;
154         }
155 
156         $xml = array_shift($areaData);
157 
158         // Parse individual configuration domains
159         $domains = $this->getDomains();
160 
161         foreach ($domains as $dom)
162         {
163             $class = 'FOFConfigDomain' . ucfirst($dom);
164 
165             if (class_exists($class, true))
166             {
167                 $o = new $class;
168                 $o->parseDomain($xml, $ret);
169             }
170         }
171 
172         // Finally, return the result
173         return $ret;
174     }
175 
176     /**
177      * Gets a list of the available configuration domain adapters
178      *
179      * @return  array  A list of the available domains
180      */
181     protected function getDomains()
182     {
183         static $domains = array();
184 
185         if (empty($domains))
186         {
187             $filesystem = FOFPlatform::getInstance()->getIntegrationObject('filesystem');
188 
189             $files = $filesystem->folderFiles(__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 }
213
Namespaces

Classes

Interfaces

Exceptions

Constants

Functions
