primo commit

libraries/fof30/Configuration/Configuration.php

@@ -0,0 +1,233 @@
+<?php
+/**
+ * @package   FOF
+ * @copyright Copyright (c)2010-2021 Nicholas K. Dionysopoulos / Akeeba Ltd
+ * @license   GNU General Public License version 2, or later
+ */
+
+namespace FOF30\Configuration;
+
+defined('_JEXEC') || die;
+
+use FOF30\Container\Container;
+
+/**
+ * Reads and parses the fof.xml file in the back-end of a FOF-powered component,
+ * provisioning the data to the rest of the FOF framework
+ *
+ * @since    2.1
+ */
+class Configuration
+{
+	/**
+	 * Cache of FOF components' configuration variables
+	 *
+	 * @var array
+	 */
+	public static $configurations = [];
+	/**
+	 * The component's container
+	 *
+	 * @var  Container
+	 */
+	protected $container = null;
+
+	function __construct(Container $c)
+	{
+		$this->container = $c;
+
+		$this->parseComponent();
+	}
+
+	/**
+	 * Returns the value of a variable. Variables use a dot notation, e.g.
+	 * view.config.whatever where the first part is the domain, the rest of the
+	 * parts specify the path to the variable.
+	 *
+	 * @param   string  $variable  The variable name
+	 * @param   mixed   $default   The default value, or null if not specified
+	 *
+	 * @return  mixed  The value of the variable
+	 */
+	public function get($variable, $default = null)
+	{
+		static $domains = null;
+
+		if (is_null($domains))
+		{
+			$domains = $this->getDomains();
+		}
+
+		[$domain, $var] = explode('.', $variable, 2);
+
+		if (!in_array(ucfirst($domain), $domains))
+		{
+			return $default;
+		}
+
+		$class = '\\FOF30\\Configuration\\Domain\\' . ucfirst($domain);
+		/** @var   \FOF30\Configuration\Domain\DomainInterface $o */
+		$o = new $class;
+
+		return $o->get(self::$configurations[$this->container->componentName], $var, $default);
+	}
+
+	/**
+	 * Parses the configuration of the specified component
+	 *
+	 * @return  void
+	 */
+	protected function parseComponent()
+	{
+		if ($this->container->platform->isCli())
+		{
+			$order = ['cli', 'backend'];
+		}
+		elseif ($this->container->platform->isBackend())
+		{
+			$order = ['backend'];
+		}
+		else
+		{
+			$order = ['frontend'];
+		}
+
+		$order[] = 'common';
+
+		$order                                                 = array_reverse($order);
+		self::$configurations[$this->container->componentName] = [];
+
+		foreach ([false, true] as $userConfig)
+		{
+			foreach ($order as $area)
+			{
+				$config                                                = $this->parseComponentArea($area, $userConfig);
+				self::$configurations[$this->container->componentName] = array_replace_recursive(self::$configurations[$this->container->componentName], $config);
+			}
+		}
+	}
+
+	/**
+	 * Parses the configuration options of a specific component area
+	 *
+	 * @param   string  $area        Which area to parse (frontend, backend, cli)
+	 * @param   bool    $userConfig  When true the user configuration (fof.user.xml) file will be read
+	 *
+	 * @return  array  A hash array with the configuration data
+	 */
+	protected function parseComponentArea($area, $userConfig = false)
+	{
+		$component = $this->container->componentName;
+
+		// Initialise the return array
+		$ret = [];
+
+		// Get the folders of the component
+		$componentPaths = $this->container->platform->getComponentBaseDirs($component);
+		$filesystem     = $this->container->filesystem;
+		$path           = $componentPaths['admin'];
+
+		if (isset($this->container['backEndPath']))
+		{
+			$path = $this->container['backEndPath'];
+		}
+
+		// This line unfortunately doesn't work with Unit Tests because JPath depends on the JPATH_SITE constant :(
+		// $path = $filesystem->pathCheck($path);
+
+		// Check that the path exists
+		if (!$filesystem->folderExists($path))
+		{
+			return $ret;
+		}
+
+		// Read the filename if it exists
+		$filename = $path . '/fof.xml';
+
+		if ($userConfig)
+		{
+			$filename = $path . '/fof.user.xml';
+		}
+
+		if (!$filesystem->fileExists($filename) && !file_exists($filename))
+		{
+			return $ret;
+		}
+
+		$data = file_get_contents($filename);
+
+		// Load the XML data in a SimpleXMLElement object
+		$xml = simplexml_load_string($data);
+
+		if (!($xml instanceof \SimpleXMLElement))
+		{
+			return $ret;
+		}
+
+		// Get this area's data
+		$areaData = $xml->xpath('//' . $area);
+
+		if (empty($areaData))
+		{
+			return $ret;
+		}
+
+		$xml = array_shift($areaData);
+
+		// Parse individual configuration domains
+		$domains = $this->getDomains();
+
+		foreach ($domains as $dom)
+		{
+			$class = '\\FOF30\\Configuration\\Domain\\' . ucfirst($dom);
+
+			if (class_exists($class, true))
+			{
+				/** @var   \FOF30\Configuration\Domain\DomainInterface $o */
+				$o = new $class;
+				$o->parseDomain($xml, $ret);
+			}
+		}
+
+		// Finally, return the result
+		return $ret;
+	}
+
+	/**
+	 * Gets a list of the available configuration domain adapters
+	 *
+	 * @return  array  A list of the available domains
+	 */
+	protected function getDomains()
+	{
+		static $domains = [];
+
+		if (empty($domains))
+		{
+			$filesystem = $this->container->filesystem;
+
+			$files = $filesystem->folderFiles(__DIR__ . '/Domain', '.php');
+
+			if (!empty($files))
+			{
+				foreach ($files as $file)
+				{
+					$domain = basename($file, '.php');
+
+					if ($domain == 'DomainInterface')
+					{
+						continue;
+					}
+
+					$domain    = preg_replace('/[^A-Za-z0-9]/', '', $domain);
+					$domains[] = $domain;
+				}
+
+				$domains = array_unique($domains);
+			}
+		}
+
+		return $domains;
+	}
+
+}

libraries/fof30/Configuration/Domain/Authentication.php

@@ -0,0 +1,81 @@
+<?php
+/**
+ * @package   FOF
+ * @copyright Copyright (c)2010-2021 Nicholas K. Dionysopoulos / Akeeba Ltd
+ * @license   GNU General Public License version 2, or later
+ */
+
+namespace FOF30\Configuration\Domain;
+
+defined('_JEXEC') || die;
+
+use SimpleXMLElement;
+
+/**
+ * Configuration parser for the authentication-specific settings
+ *
+ * @since    2.1
+ */
+class Authentication implements DomainInterface
+{
+	/**
+	 * Parse the XML data, adding them to the $ret array
+	 *
+	 * @param   SimpleXMLElement   $xml  The XML data of the component's configuration area
+	 * @param   array             &$ret  The parsed data, in the form of a hash array
+	 *
+	 * @return  void
+	 */
+	public function parseDomain(SimpleXMLElement $xml, array &$ret)
+	{
+		// Initialise
+		$ret['authentication'] = [];
+
+		// Parse the dispatcher configuration
+		$authenticationData = $xml->authentication;
+
+		// Sanity check
+
+		if (empty($authenticationData))
+		{
+			return;
+		}
+
+		$options = $xml->xpath('authentication/option');
+
+		if (!empty($options))
+		{
+			foreach ($options as $option)
+			{
+				$key                         = (string) $option['name'];
+				$ret['authentication'][$key] = (string) $option;
+			}
+		}
+	}
+
+	/**
+	 * Return a configuration variable
+	 *
+	 * @param   string  &$configuration  Configuration variables (hashed array)
+	 * @param   string   $var            The variable we want to fetch
+	 * @param   mixed    $default        Default value
+	 *
+	 * @return  mixed  The variable's value
+	 */
+	public function get(&$configuration, $var, $default)
+	{
+		if ($var == '*')
+		{
+			return $configuration['authentication'];
+		}
+
+		if (isset($configuration['authentication'][$var]))
+		{
+			return $configuration['authentication'][$var];
+		}
+		else
+		{
+			return $default;
+		}
+	}
+}

libraries/fof30/Configuration/Domain/Container.php

@@ -0,0 +1,81 @@
+<?php
+/**
+ * @package   FOF
+ * @copyright Copyright (c)2010-2021 Nicholas K. Dionysopoulos / Akeeba Ltd
+ * @license   GNU General Public License version 2, or later
+ */
+
+namespace FOF30\Configuration\Domain;
+
+defined('_JEXEC') || die;
+
+use SimpleXMLElement;
+
+/**
+ * Configuration parser for the Container-specific settings
+ *
+ * @since    2.1
+ */
+class Container implements DomainInterface
+{
+	/**
+	 * Parse the XML data, adding them to the $ret array
+	 *
+	 * @param   SimpleXMLElement   $xml  The XML data of the component's configuration area
+	 * @param   array             &$ret  The parsed data, in the form of a hash array
+	 *
+	 * @return  void
+	 */
+	public function parseDomain(SimpleXMLElement $xml, array &$ret)
+	{
+		// Initialise
+		$ret['container'] = [];
+
+		// Parse the dispatcher configuration
+		$containerData = $xml->container;
+
+		// Sanity check
+
+		if (empty($containerData))
+		{
+			return;
+		}
+
+		$options = $xml->xpath('container/option');
+
+		if (!empty($options))
+		{
+			foreach ($options as $option)
+			{
+				$key                    = (string) $option['name'];
+				$ret['container'][$key] = (string) $option;
+			}
+		}
+	}
+
+	/**
+	 * Return a configuration variable
+	 *
+	 * @param   string  &$configuration  Configuration variables (hashed array)
+	 * @param   string   $var            The variable we want to fetch
+	 * @param   mixed    $default        Default value
+	 *
+	 * @return  mixed  The variable's value
+	 */
+	public function get(&$configuration, $var, $default)
+	{
+		if ($var == '*')
+		{
+			return $configuration['container'];
+		}
+
+		if (isset($configuration['container'][$var]))
+		{
+			return $configuration['container'][$var];
+		}
+		else
+		{
+			return $default;
+		}
+	}
+}

libraries/fof30/Configuration/Domain/Dispatcher.php

@@ -0,0 +1,81 @@
+<?php
+/**
+ * @package   FOF
+ * @copyright Copyright (c)2010-2021 Nicholas K. Dionysopoulos / Akeeba Ltd
+ * @license   GNU General Public License version 2, or later
+ */
+
+namespace FOF30\Configuration\Domain;
+
+defined('_JEXEC') || die;
+
+use SimpleXMLElement;
+
+/**
+ * Configuration parser for the dispatcher-specific settings
+ *
+ * @since    2.1
+ */
+class Dispatcher implements DomainInterface
+{
+	/**
+	 * Parse the XML data, adding them to the $ret array
+	 *
+	 * @param   SimpleXMLElement   $xml  The XML data of the component's configuration area
+	 * @param   array             &$ret  The parsed data, in the form of a hash array
+	 *
+	 * @return  void
+	 */
+	public function parseDomain(SimpleXMLElement $xml, array &$ret)
+	{
+		// Initialise
+		$ret['dispatcher'] = [];
+
+		// Parse the dispatcher configuration
+		$dispatcherData = $xml->dispatcher;
+
+		// Sanity check
+
+		if (empty($dispatcherData))
+		{
+			return;
+		}
+
+		$options = $xml->xpath('dispatcher/option');
+
+		if (!empty($options))
+		{
+			foreach ($options as $option)
+			{
+				$key                     = (string) $option['name'];
+				$ret['dispatcher'][$key] = (string) $option;
+			}
+		}
+	}
+
+	/**
+	 * Return a configuration variable
+	 *
+	 * @param   string  &$configuration  Configuration variables (hashed array)
+	 * @param   string   $var            The variable we want to fetch
+	 * @param   mixed    $default        Default value
+	 *
+	 * @return  mixed  The variable's value
+	 */
+	public function get(&$configuration, $var, $default)
+	{
+		if ($var == '*')
+		{
+			return $configuration['dispatcher'];
+		}
+
+		if (isset($configuration['dispatcher'][$var]))
+		{
+			return $configuration['dispatcher'][$var];
+		}
+		else
+		{
+			return $default;
+		}
+	}
+}

libraries/fof30/Configuration/Domain/DomainInterface.php

@@ -0,0 +1,43 @@
+<?php
+/**
+ * @package   FOF
+ * @copyright Copyright (c)2010-2021 Nicholas K. Dionysopoulos / Akeeba Ltd
+ * @license   GNU General Public License version 2, or later
+ */
+
+namespace FOF30\Configuration\Domain;
+
+defined('_JEXEC') || die;
+
+use SimpleXMLElement;
+
+/**
+ * The Interface of a FOF configuration domain class. The methods are used to parse and
+ * provision sensible information to consumers. The Configuration class acts as an
+ * adapter to the domain classes.
+ *
+ * @since    2.1
+ */
+interface DomainInterface
+{
+	/**
+	 * Parse the XML data, adding them to the $ret array
+	 *
+	 * @param   SimpleXMLElement   $xml  The XML data of the component's configuration area
+	 * @param   array             &$ret  The parsed data, in the form of a hash array
+	 *
+	 * @return  void
+	 */
+	public function parseDomain(SimpleXMLElement $xml, array &$ret);
+
+	/**
+	 * Return a configuration variable
+	 *
+	 * @param   string  &$configuration  Configuration variables (hashed array)
+	 * @param   string   $var            The variable we want to fetch
+	 * @param   mixed    $default        Default value
+	 *
+	 * @return  mixed  The variable's value
+	 */
+	public function get(&$configuration, $var, $default);
+}

libraries/fof30/Configuration/Domain/Models.php

@@ -0,0 +1,369 @@
+<?php
+/**
+ * @package   FOF
+ * @copyright Copyright (c)2010-2021 Nicholas K. Dionysopoulos / Akeeba Ltd
+ * @license   GNU General Public License version 2, or later
+ */
+
+namespace FOF30\Configuration\Domain;
+
+defined('_JEXEC') || die;
+
+use SimpleXMLElement;
+
+/**
+ * Configuration parser for the models-specific settings
+ *
+ * @since    2.1
+ */
+class Models implements DomainInterface
+{
+	/**
+	 * Parse the XML data, adding them to the $ret array
+	 *
+	 * @param   SimpleXMLElement  $xml  The XML data of the component's configuration area
+	 * @param   array            &$ret  The parsed data, in the form of a hash array
+	 *
+	 * @return  void
+	 */
+	public function parseDomain(SimpleXMLElement $xml, array &$ret)
+	{
+		// Initialise
+		$ret['models'] = [];
+
+		// Parse model configuration
+		$modelsData = $xml->xpath('model');
+
+		// Sanity check
+		if (empty($modelsData))
+		{
+			return;
+		}
+
+		foreach ($modelsData as $aModel)
+		{
+			$key = (string) $aModel['name'];
+
+			$ret['models'][$key]['behaviors']      = [];
+			$ret['models'][$key]['behaviorsMerge'] = false;
+			$ret['models'][$key]['tablealias']     = $aModel->xpath('tablealias');
+			$ret['models'][$key]['fields']         = [];
+			$ret['models'][$key]['relations']      = [];
+			$ret['models'][$key]['config']         = [];
+
+
+			// Parse configuration
+			$optionData = $aModel->xpath('config/option');
+
+			if (!empty($optionData))
+			{
+				foreach ($optionData as $option)
+				{
+					$k                                 = (string) $option['name'];
+					$ret['models'][$key]['config'][$k] = (string) $option;
+				}
+			}
+
+			// Parse field aliases
+			$fieldData = $aModel->xpath('field');
+
+			if (!empty($fieldData))
+			{
+				foreach ($fieldData as $field)
+				{
+					$k                                 = (string) $field['name'];
+					$ret['models'][$key]['fields'][$k] = (string) $field;
+				}
+			}
+
+			// Parse behaviours
+			$behaviorsData  = (string) $aModel->behaviors;
+			$behaviorsMerge = (string) $aModel->behaviors['merge'];
+
+			if (!empty($behaviorsMerge))
+			{
+				$behaviorsMerge = trim($behaviorsMerge);
+				$behaviorsMerge = strtoupper($behaviorsMerge);
+
+				if (in_array($behaviorsMerge, ['1', 'YES', 'ON', 'TRUE']))
+				{
+					$ret['models'][$key]['behaviorsMerge'] = true;
+				}
+			}
+
+			if (!empty($behaviorsData))
+			{
+				$behaviorsData = explode(',', $behaviorsData);
+
+				foreach ($behaviorsData as $behavior)
+				{
+					$behavior = trim($behavior);
+
+					if (empty($behavior))
+					{
+						continue;
+					}
+
+					$ret['models'][$key]['behaviors'][] = $behavior;
+				}
+			}
+
+			// Parse relations
+			$relationsData = $aModel->xpath('relation');
+
+			if (!empty($relationsData))
+			{
+				foreach ($relationsData as $relationData)
+				{
+					$type     = (string) $relationData['type'];
+					$itemName = (string) $relationData['name'];
+
+					if (empty($type) || empty($itemName))
+					{
+						continue;
+					}
+
+					$modelClass    = (string) $relationData['foreignModelClass'];
+					$localKey      = (string) $relationData['localKey'];
+					$foreignKey    = (string) $relationData['foreignKey'];
+					$pivotTable    = (string) $relationData['pivotTable'];
+					$ourPivotKey   = (string) $relationData['pivotLocalKey'];
+					$theirPivotKey = (string) $relationData['pivotForeignKey'];
+
+					$relation = [
+						'type'              => $type,
+						'itemName'          => $itemName,
+						'foreignModelClass' => empty($modelClass) ? null : $modelClass,
+						'localKey'          => empty($localKey) ? null : $localKey,
+						'foreignKey'        => empty($foreignKey) ? null : $foreignKey,
+					];
+
+					if (!empty($ourPivotKey) || !empty($theirPivotKey) || !empty($pivotTable))
+					{
+						$relation['pivotLocalKey']   = empty($ourPivotKey) ? null : $ourPivotKey;
+						$relation['pivotForeignKey'] = empty($theirPivotKey) ? null : $theirPivotKey;
+						$relation['pivotTable']      = empty($pivotTable) ? null : $pivotTable;
+					}
+
+					$ret['models'][$key]['relations'][] = $relation;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Return a configuration variable
+	 *
+	 * @param   string &$configuration  Configuration variables (hashed array)
+	 * @param   string  $var            The variable we want to fetch
+	 * @param   mixed   $default        Default value
+	 *
+	 * @return  mixed  The variable's value
+	 */
+	public function get(&$configuration, $var, $default)
+	{
+		$parts = explode('.', $var);
+
+		$view   = $parts[0];
+		$method = 'get' . ucfirst($parts[1]);
+
+		if (!method_exists($this, $method))
+		{
+			return $default;
+		}
+
+		array_shift($parts);
+		array_shift($parts);
+
+		$ret = $this->$method($view, $configuration, $parts, $default);
+
+		return $ret;
+	}
+
+	/**
+	 * Internal method to return the magic field mapping
+	 *
+	 * @param   string  $model          The model for which we will be fetching a field map
+	 * @param   array  &$configuration  The configuration parameters hash array
+	 * @param   array   $params         Extra options
+	 * @param   string  $default        Default magic field mapping; empty if not defined
+	 *
+	 * @return  array   Field map
+	 */
+	protected function getField($model, &$configuration, $params, $default = '')
+	{
+		$fieldmap = [];
+
+		if (isset($configuration['models']['*']) && isset($configuration['models']['*']['fields']))
+		{
+			$fieldmap = $configuration['models']['*']['fields'];
+		}
+
+		if (isset($configuration['models'][$model]) && isset($configuration['models'][$model]['fields']))
+		{
+			$fieldmap = array_merge($fieldmap, $configuration['models'][$model]['fields']);
+		}
+
+		$map = $default;
+
+		if (empty($params[0]) || ($params[0] == '*'))
+		{
+			$map = $fieldmap;
+		}
+		elseif (isset($fieldmap[$params[0]]))
+		{
+			$map = $fieldmap[$params[0]];
+		}
+
+		return $map;
+	}
+
+	/**
+	 * Internal method to get model alias
+	 *
+	 * @param   string  $model          The model for which we will be fetching table alias
+	 * @param   array  &$configuration  The configuration parameters hash array
+	 * @param   array   $params         Ignored
+	 * @param   string  $default        Default table alias
+	 *
+	 * @return  string  Table alias
+	 */
+	protected function getTablealias($model, &$configuration, $params, $default = '')
+	{
+		$tableMap = [];
+
+		if (isset($configuration['models']['*']['tablealias']))
+		{
+			$tableMap = $configuration['models']['*']['tablealias'];
+		}
+
+		if (isset($configuration['models'][$model]['tablealias']))
+		{
+			$tableMap = array_merge($tableMap, $configuration['models'][$model]['tablealias']);
+		}
+
+		if (empty($tableMap))
+		{
+			return null;
+		}
+
+		return $tableMap[0];
+	}
+
+	/**
+	 * Internal method to get model behaviours
+	 *
+	 * @param   string  $model          The model for which we will be fetching behaviours
+	 * @param   array  &$configuration  The configuration parameters hash array
+	 * @param   array   $params         Unused
+	 * @param   string  $default        Default behaviour
+	 *
+	 * @return  string  Model behaviours
+	 */
+	protected function getBehaviors($model, &$configuration, $params, $default = '')
+	{
+		$behaviors = $default;
+
+		if (isset($configuration['models']['*'])
+			&& isset($configuration['models']['*']['behaviors'])
+		)
+		{
+			$behaviors = $configuration['models']['*']['behaviors'];
+		}
+
+		if (isset($configuration['models'][$model])
+			&& isset($configuration['models'][$model]['behaviors'])
+		)
+		{
+			$merge = false;
+
+			if (isset($configuration['models'][$model])
+				&& isset($configuration['models'][$model]['behaviorsMerge'])
+			)
+			{
+				$merge = (bool) $configuration['models'][$model]['behaviorsMerge'];
+			}
+
+			if ($merge)
+			{
+				$behaviors = array_merge($behaviors, $configuration['models'][$model]['behaviors']);
+			}
+			else
+			{
+				$behaviors = $configuration['models'][$model]['behaviors'];
+			}
+		}
+
+		return $behaviors;
+	}
+
+	/**
+	 * Internal method to get model relations
+	 *
+	 * @param   string  $model          The model for which we will be fetching relations
+	 * @param   array  &$configuration  The configuration parameters hash array
+	 * @param   array   $params         Unused
+	 * @param   string  $default        Default relations
+	 *
+	 * @return  array   Model relations
+	 */
+	protected function getRelations($model, &$configuration, $params, $default = '')
+	{
+		$relations = $default;
+
+		if (isset($configuration['models']['*'])
+			&& isset($configuration['models']['*']['relations'])
+		)
+		{
+			$relations = $configuration['models']['*']['relations'];
+		}
+
+		if (isset($configuration['models'][$model])
+			&& isset($configuration['models'][$model]['relations'])
+		)
+		{
+			$relations = $configuration['models'][$model]['relations'];
+		}
+
+		return $relations;
+	}
+
+	/**
+	 * Internal method to return the a configuration option for the Model.
+	 *
+	 * @param   string  $model          The view for which we will be fetching a task map
+	 * @param   array  &$configuration  The configuration parameters hash array
+	 * @param   array   $params         Extra options; key 0 defines the option variable we want to fetch
+	 * @param   mixed   $default        Default option; null if not defined
+	 *
+	 * @return  string  The setting for the requested option
+	 */
+	protected function getConfig($model, &$configuration, $params, $default = null)
+	{
+		$ret = $default;
+
+		$config = [];
+
+		if (isset($configuration['models']['*']['config']))
+		{
+			$config = $configuration['models']['*']['config'];
+		}
+
+		if (isset($configuration['models'][$model]['config']))
+		{
+			$config = array_merge($config, $configuration['models'][$model]['config']);
+		}
+
+		if (empty($params) || empty($params[0]))
+		{
+			return $config;
+		}
+
+		if (isset($config[$params[0]]))
+		{
+			$ret = $config[$params[0]];
+		}
+
+		return $ret;
+	}
+}

libraries/fof30/Configuration/Domain/Views.php

@@ -0,0 +1,317 @@
+<?php
+/**
+ * @package   FOF
+ * @copyright Copyright (c)2010-2021 Nicholas K. Dionysopoulos / Akeeba Ltd
+ * @license   GNU General Public License version 2, or later
+ */
+
+namespace FOF30\Configuration\Domain;
+
+defined('_JEXEC') || die;
+
+use SimpleXMLElement;
+
+/**
+ * Configuration parser for the view-specific settings
+ *
+ * @since    2.1
+ */
+class Views implements DomainInterface
+{
+	/**
+	 * Parse the XML data, adding them to the $ret array
+	 *
+	 * @param   SimpleXMLElement   $xml  The XML data of the component's configuration area
+	 * @param   array             &$ret  The parsed data, in the form of a hash array
+	 *
+	 * @return  void
+	 */
+	public function parseDomain(SimpleXMLElement $xml, array &$ret)
+	{
+		// Initialise
+		$ret['views'] = [];
+
+		// Parse view configuration
+		$viewData = $xml->xpath('view');
+
+		// Sanity check
+
+		if (empty($viewData))
+		{
+			return;
+		}
+
+		foreach ($viewData as $aView)
+		{
+			$key = (string) $aView['name'];
+
+			// Parse ACL options
+			$ret['views'][$key]['acl'] = [];
+			$aclData                   = $aView->xpath('acl/task');
+
+			if (!empty($aclData))
+			{
+				foreach ($aclData as $acl)
+				{
+					$k                             = (string) $acl['name'];
+					$ret['views'][$key]['acl'][$k] = (string) $acl;
+				}
+			}
+
+			// Parse taskmap
+			$ret['views'][$key]['taskmap'] = [];
+			$taskmapData                   = $aView->xpath('taskmap/task');
+
+			if (!empty($taskmapData))
+			{
+				foreach ($taskmapData as $map)
+				{
+					$k                                 = (string) $map['name'];
+					$ret['views'][$key]['taskmap'][$k] = (string) $map;
+				}
+			}
+
+			// Parse controller configuration
+			$ret['views'][$key]['config'] = [];
+			$optionData                   = $aView->xpath('config/option');
+
+			if (!empty($optionData))
+			{
+				foreach ($optionData as $option)
+				{
+					$k                                = (string) $option['name'];
+					$ret['views'][$key]['config'][$k] = (string) $option;
+				}
+			}
+
+			// Parse the toolbar
+			$ret['views'][$key]['toolbar'] = [];
+			$toolBars                      = $aView->xpath('toolbar');
+
+			if (!empty($toolBars))
+			{
+				foreach ($toolBars as $toolBar)
+				{
+					$taskName = isset($toolBar['task']) ? (string) $toolBar['task'] : '*';
+
+					// If a toolbar title is specified, create a title element.
+					if (isset($toolBar['title']))
+					{
+						$ret['views'][$key]['toolbar'][$taskName]['title'] = [
+							'value' => (string) $toolBar['title'],
+						];
+					}
+
+					// Parse the toolbar buttons data
+					$toolbarData = $toolBar->xpath('button');
+
+					if (!empty($toolbarData))
+					{
+						foreach ($toolbarData as $button)
+						{
+							$k                                                     = (string) $button['type'];
+							$ret['views'][$key]['toolbar'][$taskName][$k]          = current($button->attributes());
+							$ret['views'][$key]['toolbar'][$taskName][$k]['value'] = (string) $button;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Return a configuration variable
+	 *
+	 * @param   string  &$configuration  Configuration variables (hashed array)
+	 * @param   string   $var            The variable we want to fetch
+	 * @param   mixed    $default        Default value
+	 *
+	 * @return  mixed  The variable's value
+	 */
+	public function get(&$configuration, $var, $default)
+	{
+		$parts = explode('.', $var);
+
+		$view   = $parts[0];
+		$method = 'get' . ucfirst($parts[1]);
+
+		if (!method_exists($this, $method))
+		{
+			return $default;
+		}
+
+		array_shift($parts);
+		array_shift($parts);
+
+		$ret = $this->$method($view, $configuration, $parts, $default);
+
+		return $ret;
+	}
+
+	/**
+	 * Internal function to return the task map for a view
+	 *
+	 * @param   string   $view           The view for which we will be fetching a task map
+	 * @param   array   &$configuration  The configuration parameters hash array
+	 * @param   array    $params         Extra options (not used)
+	 * @param   array    $default        ßDefault task map; empty array if not provided
+	 *
+	 * @return  array  The task map as a hash array in the format task => method
+	 */
+	protected function getTaskmap($view, &$configuration, $params, $default = [])
+	{
+		$taskmap = [];
+
+		if (isset($configuration['views']['*']) && isset($configuration['views']['*']['taskmap']))
+		{
+			$taskmap = $configuration['views']['*']['taskmap'];
+		}
+
+		if (isset($configuration['views'][$view]) && isset($configuration['views'][$view]['taskmap']))
+		{
+			$taskmap = array_merge($taskmap, $configuration['views'][$view]['taskmap']);
+		}
+
+		if (empty($taskmap))
+		{
+			return $default;
+		}
+
+		return $taskmap;
+	}
+
+	/**
+	 * Internal method to return the ACL mapping (privilege required to access
+	 * a specific task) for the given view's tasks
+	 *
+	 * @param   string   $view           The view for which we will be fetching a task map
+	 * @param   array   &$configuration  The configuration parameters hash array
+	 * @param   array    $params         Extra options; key 0 defines the task we want to fetch
+	 * @param   string   $default        Default ACL option; empty (no ACL check) if not defined
+	 *
+	 * @return  string  The privilege required to access this view
+	 */
+	protected function getAcl($view, &$configuration, $params, $default = '')
+	{
+		$aclmap = [];
+
+		if (isset($configuration['views']['*']) && isset($configuration['views']['*']['acl']))
+		{
+			$aclmap = $configuration['views']['*']['acl'];
+		}
+
+		if (isset($configuration['views'][$view]) && isset($configuration['views'][$view]['acl']))
+		{
+			$aclmap = array_merge($aclmap, $configuration['views'][$view]['acl']);
+		}
+
+		$acl = $default;
+
+		if (empty($params) || empty($params[0]))
+		{
+			return $aclmap;
+		}
+
+		if (isset($aclmap['*']))
+		{
+			$acl = $aclmap['*'];
+		}
+
+		if (isset($aclmap[$params[0]]))
+		{
+			$acl = $aclmap[$params[0]];
+		}
+
+		return $acl;
+	}
+
+	/**
+	 * Internal method to return the a configuration option for the view. These
+	 * are equivalent to $config array options passed to the Controller
+	 *
+	 * @param   string   $view           The view for which we will be fetching a task map
+	 * @param   array   &$configuration  The configuration parameters hash array
+	 * @param   array    $params         Extra options; key 0 defines the option variable we want to fetch
+	 * @param   mixed    $default        Default option; null if not defined
+	 *
+	 * @return  string  The setting for the requested option
+	 */
+	protected function getConfig($view, &$configuration, $params, $default = null)
+	{
+		$ret = $default;
+
+		$config = [];
+
+		if (isset($configuration['views']['*']['config']))
+		{
+			$config = $configuration['views']['*']['config'];
+		}
+
+		if (isset($configuration['views'][$view]['config']))
+		{
+			$config = array_merge($config, $configuration['views'][$view]['config']);
+		}
+
+		if (empty($params) || empty($params[0]))
+		{
+			return $config;
+		}
+
+		if (isset($config[$params[0]]))
+		{
+			$ret = $config[$params[0]];
+		}
+
+		return $ret;
+	}
+
+	/**
+	 * Internal method to return the toolbar infos.
+	 *
+	 * @param   string   $view           The view for which we will be fetching buttons
+	 * @param   array   &$configuration  The configuration parameters hash array
+	 * @param   array    $params         Extra options
+	 * @param   string   $default        Default option
+	 *
+	 * @return  string  The toolbar data for this view
+	 */
+	protected function getToolbar($view, &$configuration, $params, $default = '')
+	{
+		$toolbar = [];
+
+		if (isset($configuration['views']['*'])
+			&& isset($configuration['views']['*']['toolbar'])
+			&& isset($configuration['views']['*']['toolbar']['*']))
+		{
+			$toolbar = $configuration['views']['*']['toolbar']['*'];
+		}
+
+		if (isset($configuration['views']['*'])
+			&& isset($configuration['views']['*']['toolbar'])
+			&& isset($configuration['views']['*']['toolbar'][$params[0]]))
+		{
+			$toolbar = array_merge($toolbar, $configuration['views']['*']['toolbar'][$params[0]]);
+		}
+
+		if (isset($configuration['views'][$view])
+			&& isset($configuration['views'][$view]['toolbar'])
+			&& isset($configuration['views'][$view]['toolbar']['*']))
+		{
+			$toolbar = array_merge($toolbar, $configuration['views'][$view]['toolbar']['*']);
+		}
+
+		if (isset($configuration['views'][$view])
+			&& isset($configuration['views'][$view]['toolbar'])
+			&& isset($configuration['views'][$view]['toolbar'][$params[0]]))
+		{
+			$toolbar = array_merge($toolbar, $configuration['views'][$view]['toolbar'][$params[0]]);
+		}
+
+		if (empty($toolbar))
+		{
+			return $default;
+		}
+
+		return $toolbar;
+	}
+}