Your IP : 216.73.217.68
PK +#]P���> �> LdapClient.phpnu &1i� <?php
/**
* Part of the Joomla Framework LDAP Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Ldap;
/**
* LDAP client class
*
* @since 1.0
* @deprecated The joomla/ldap package is deprecated
*/
class LdapClient
{
/**
* Hostname of LDAP server
*
* @var string
* @since 1.0
*/
public $host;
/**
* Authorization Method to use
*
* @var boolean
* @since 1.0
*/
public $auth_method;
/**
* Port of LDAP server
*
* @var integer
* @since 1.0
*/
public $port;
/**
* Base DN (e.g. o=MyDir)
*
* @var string
* @since 1.0
*/
public $base_dn;
/**
* User DN (e.g. cn=Users,o=MyDir)
*
* @var string
* @since 1.0
*/
public $users_dn;
/**
* Search String
*
* @var string
* @since 1.0
*/
public $search_string;
/**
* Use LDAP Version 3
*
* @var boolean
* @since 1.0
*/
public $use_ldapV3;
/**
* No referrals (server transfers)
*
* @var boolean
* @since 1.0
*/
public $no_referrals;
/**
* Negotiate TLS (encrypted communications)
*
* @var boolean
* @since 1.0
*/
public $negotiate_tls;
/**
* Ignore TLS Certificate (encrypted communications)
*
* @var boolean
* @since 1.5.0
*/
public $ignore_reqcert_tls;
/**
* Enable LDAP debug
*
* @var boolean
* @since 1.5.0
*/
public $ldap_debug;
/**
* Username to connect to server
*
* @var string
* @since 1.0
*/
public $username;
/**
* Password to connect to server
*
* @var string
* @since 1.0
*/
public $password;
/**
* LDAP Resource Identifier
*
* @var resource
* @since 1.0
*/
private $resource;
/**
* Current DN
*
* @var string
* @since 1.0
*/
private $dn;
/**
* Flag tracking whether the connection has been bound
*
* @var boolean
* @since 1.3.0
*/
private $isBound = false;
/**
* Constructor
*
* @param object $configObj An object of configuration variables
*
* @since 1.0
*/
public function __construct($configObj = null)
{
if (\is_object($configObj))
{
$vars = get_class_vars(\get_class($this));
foreach (array_keys($vars) as $var)
{
if (substr($var, 0, 1) != '_')
{
$param = $configObj->get($var);
if ($param)
{
$this->$var = $param;
}
}
}
}
}
/**
* Class destructor.
*
* @since 1.3.0
*/
public function __destruct()
{
$this->close();
}
/**
* Connect to an LDAP server
*
* @return boolean
*
* @since 1.0
*/
public function connect()
{
if ($this->host == '')
{
return false;
}
if ($this->ignore_reqcert_tls)
{
putenv('LDAPTLS_REQCERT=never');
}
if ($this->ldap_debug)
{
ldap_set_option(null, LDAP_OPT_DEBUG_LEVEL, 7);
}
$this->resource = ldap_connect($this->host, $this->port);
if (!$this->resource)
{
return false;
}
if ($this->use_ldapV3 && !ldap_set_option($this->resource, LDAP_OPT_PROTOCOL_VERSION, 3))
{
return false;
}
if (!ldap_set_option($this->resource, LDAP_OPT_REFERRALS, (int) $this->no_referrals))
{
return false;
}
if ($this->negotiate_tls && !ldap_start_tls($this->resource))
{
return false;
}
return true;
}
/**
* Close the connection
*
* @return void
*
* @since 1.0
*/
public function close()
{
if ($this->isConnected())
{
$this->unbind();
}
$this->resource = null;
}
/**
* Sets the DN with some template replacements
*
* @param string $username The username
* @param string $nosub ...
*
* @return void
*
* @since 1.0
*/
public function setDn($username, $nosub = 0)
{
if ($this->users_dn == '' || $nosub)
{
$this->dn = $username;
}
elseif (\strlen($username))
{
$this->dn = str_replace('[username]', $username, $this->users_dn);
}
else
{
$this->dn = '';
}
}
/**
* Get the configured DN
*
* @return string
*
* @since 1.0
*/
public function getDn()
{
return $this->dn;
}
/**
* Anonymously binds to LDAP directory
*
* @return boolean
*
* @since 1.0
*/
public function anonymous_bind()
{
if (!$this->isConnected())
{
if (!$this->connect())
{
return false;
}
}
$this->isBound = ldap_bind($this->resource);
return $this->isBound;
}
/**
* Binds to the LDAP directory
*
* @param string $username The username
* @param string $password The password
* @param string $nosub ...
*
* @return boolean
*
* @since 1.0
*/
public function bind($username = null, $password = null, $nosub = 0)
{
if (!$this->isConnected())
{
if (!$this->connect())
{
return false;
}
}
if ($username === null)
{
$username = $this->username;
}
if ($password === null)
{
$password = $this->password;
}
$this->setDn($username, $nosub);
$this->isBound = ldap_bind($this->resource, $this->getDn(), $password);
return $this->isBound;
}
/**
* Unbinds from the LDAP directory
*
* @return boolean
*
* @since 1.3.0
*/
public function unbind()
{
if ($this->isBound && $this->resource && \is_resource($this->resource))
{
return ldap_unbind($this->resource);
}
return true;
}
/**
* Perform an LDAP search using comma separated search strings
*
* @param string $search search string of search values
*
* @return array Search results
*
* @since 1.0
*/
public function simple_search($search)
{
$results = explode(';', $search);
foreach ($results as $key => $result)
{
$results[$key] = '(' . $result . ')';
}
return $this->search($results);
}
/**
* Performs an LDAP search
*
* @param array $filters Search Filters (array of strings)
* @param string $dnoverride DN Override
* @param array $attributes An array of attributes to return (if empty, all fields are returned).
*
* @return array Multidimensional array of results
*
* @since 1.0
*/
public function search(array $filters, $dnoverride = null, array $attributes = array())
{
$result = array();
if (!$this->isBound || !$this->isConnected())
{
return $result;
}
if ($dnoverride)
{
$dn = $dnoverride;
}
else
{
$dn = $this->base_dn;
}
foreach ($filters as $searchFilter)
{
$searchResult = ldap_search($this->resource, $dn, $searchFilter, $attributes);
if ($searchResult && ($count = ldap_count_entries($this->resource, $searchResult)) > 0)
{
for ($i = 0; $i < $count; $i++)
{
$result[$i] = array();
if (!$i)
{
$firstentry = ldap_first_entry($this->resource, $searchResult);
}
else
{
$firstentry = ldap_next_entry($this->resource, $firstentry);
}
// Load user-specified attributes
$attributeResult = ldap_get_attributes($this->resource, $firstentry);
// LDAP returns an array of arrays, fit this into attributes result array
foreach ($attributeResult as $ki => $ai)
{
if (\is_array($ai))
{
$subcount = $ai['count'];
$result[$i][$ki] = array();
for ($k = 0; $k < $subcount; $k++)
{
$result[$i][$ki][$k] = $ai[$k];
}
}
}
$result[$i]['dn'] = ldap_get_dn($this->resource, $firstentry);
}
}
}
return $result;
}
/**
* Replace attribute values with new ones
*
* @param string $dn The DN which contains the attribute you want to replace
* @param string $attribute The attribute values you want to replace
*
* @return boolean
*
* @since 1.0
*/
public function replace($dn, $attribute)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_mod_replace($this->resource, $dn, $attribute);
}
/**
* Modify an LDAP entry
*
* @param string $dn The DN which contains the attribute you want to modify
* @param string $attribute The attribute values you want to modify
*
* @return boolean
*
* @since 1.0
*/
public function modify($dn, $attribute)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_modify($this->resource, $dn, $attribute);
}
/**
* Delete attribute values from current attributes
*
* @param string $dn The DN which contains the attribute you want to remove
* @param string $attribute The attribute values you want to remove
*
* @return boolean
*
* @since 1.0
*/
public function remove($dn, $attribute)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_mod_del($this->resource, $dn, $attribute);
}
/**
* Compare value of attribute found in entry specified with DN
*
* @param string $dn The DN which contains the attribute you want to compare
* @param string $attribute The attribute whose value you want to compare
* @param string $value The value you want to check against the LDAP attribute
*
* @return boolean|integer Boolean result of the comparison or -1 on error
*
* @since 1.0
*/
public function compare($dn, $attribute, $value)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_compare($this->resource, $dn, $attribute, $value);
}
/**
* Read attributes of a given DN
*
* @param string $dn The DN of the object you want to read
*
* @return array|boolean Array of attributes for the given DN or boolean false on failure
*
* @since 1.0
*/
public function read($dn)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
$base = substr($dn, strpos($dn, ',') + 1);
$cn = substr($dn, 0, strpos($dn, ','));
$result = ldap_read($this->resource, $base, $cn);
if ($result === false)
{
return false;
}
return ldap_get_entries($this->resource, $result);
}
/**
* Delete an entry from a directory
*
* @param string $dn The DN of the object you want to delete
*
* @return boolean
*
* @since 1.0
*/
public function delete($dn)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_delete($this->resource, $dn);
}
/**
* Add entries to LDAP directory
*
* @param string $dn The DN where you want to put the object
* @param array $entries An array of arrays describing the object to add
*
* @return boolean
*
* @since 1.0
*/
public function create($dn, array $entries)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_add($this->resource, $dn, $entries);
}
/**
* Add attribute values to current attributes
*
* @param string $dn The DN of the entry to add the attribute
* @param array $entry An array of arrays with attributes to add
*
* @return boolean
*
* @since 1.0
*/
public function add($dn, array $entry)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_mod_add($this->resource, $dn, $entry);
}
/**
* Modify the name of an entry
*
* @param string $dn The DN of the entry at the moment
* @param string $newdn The DN of the entry should be (only cn=newvalue)
* @param string $newparent The full DN of the parent (null by default)
* @param boolean $deleteolddn Delete the old values (default)
*
* @return boolean
*
* @since 1.0
*/
public function rename($dn, $newdn, $newparent, $deleteolddn)
{
if (!$this->isBound || !$this->isConnected())
{
return false;
}
return ldap_rename($this->resource, $dn, $newdn, $newparent, $deleteolddn);
}
/**
* Escape a string
*
* @param string $value The subject string
* @param string $ignore Characters to ignore when escaping.
* @param integer $flags The context the escaped string will be used in LDAP_ESCAPE_FILTER or LDAP_ESCAPE_DN
*
* @return string
*
* @since 1.2.0
*/
public function escape($value, $ignore = '', $flags = 0)
{
return ldap_escape($value, $ignore, $flags);
}
/**
* Return the LDAP error message of the last LDAP command
*
* @return string
*
* @since 1.0
*/
public function getErrorMsg()
{
if (!$this->isBound || !$this->isConnected())
{
return '';
}
return ldap_error($this->resource);
}
/**
* Check if the connection is established
*
* @return boolean
*
* @since 1.3.0
*/
public function isConnected()
{
return $this->resource && \is_resource($this->resource);
}
/**
* Converts a dot notation IP address to net address (e.g. for Netware, etc)
*
* @param string $ip IP Address (e.g. xxx.xxx.xxx.xxx)
*
* @return string
*
* @since 1.0
*/
public static function ipToNetAddress($ip)
{
$parts = explode('.', $ip);
$address = '1#';
foreach ($parts as $int)
{
$tmp = dechex($int);
if (\strlen($tmp) != 2)
{
$tmp = '0' . $tmp;
}
$address .= '\\' . $tmp;
}
return $address;
}
/**
* Extract readable network address from the LDAP encoded networkAddress attribute.
*
* Please keep this document block and author attribution in place.
*
* Novell Docs, see: http://developer.novell.com/ndk/doc/ndslib/schm_enu/data/sdk5624.html#sdk5624
* for Address types: http://developer.novell.com/ndk/doc/ndslib/index.html?page=/ndk/doc/ndslib/schm_enu/data/sdk4170.html
* LDAP Format, String:
* taggedData = uint32String "#" octetstring
* byte 0 = uint32String = Address Type: 0= IPX Address; 1 = IP Address
* byte 1 = char = "#" - separator
* byte 2+ = octetstring - the ordinal value of the address
* Note: with eDirectory 8.6.2, the IP address (type 1) returns
* correctly, however, an IPX address does not seem to. eDir 8.7 may correct this.
* Enhancement made by Merijn van de Schoot:
* If addresstype is 8 (UDP) or 9 (TCP) do some additional parsing like still returning the IP address
*
* @param string $networkaddress The network address
*
* @return array
*
* @author Jay Burrell, Systems & Networks, Mississippi State University
* @since 1.0
*/
public static function ldapNetAddr($networkaddress)
{
$addr = '';
$addrtype = (int) substr($networkaddress, 0, 1);
// Throw away bytes 0 and 1 which should be the addrtype and the "#" separator
$networkaddress = substr($networkaddress, 2);
if (($addrtype == 8) || ($addrtype = 9))
{
// TODO 1.6: If UDP or TCP, (TODO fill addrport and) strip portnumber information from address
$networkaddress = substr($networkaddress, (\strlen($networkaddress) - 4));
}
$addrtypes = array(
'IPX',
'IP',
'SDLC',
'Token Ring',
'OSI',
'AppleTalk',
'NetBEUI',
'Socket',
'UDP',
'TCP',
'UDP6',
'TCP6',
'Reserved (12)',
'URL',
'Count',
);
$len = \strlen($networkaddress);
if ($len > 0)
{
for ($i = 0; $i < $len; $i++)
{
$byte = substr($networkaddress, $i, 1);
$addr .= \ord($byte);
if (($addrtype == 1) || ($addrtype == 8) || ($addrtype = 9))
{
// Dot separate IP addresses...
$addr .= '.';
}
}
if (($addrtype == 1) || ($addrtype == 8) || ($addrtype = 9))
{
// Strip last period from end of $addr
$addr = substr($addr, 0, \strlen($addr) - 1);
}
}
else
{
$addr .= 'Address not available.';
}
return array('protocol' => $addrtypes[$addrtype], 'address' => $addr);
}
/**
* Generates a LDAP compatible password
*
* @param string $password Clear text password to encrypt
* @param string $type Type of password hash, either md5 or SHA
*
* @return string
*
* @since 1.0
*/
public static function generatePassword($password, $type = 'md5')
{
switch (strtolower($type))
{
case 'sha':
return '{SHA}' . base64_encode(pack('H*', sha1($password)));
case 'md5':
default:
return '{MD5}' . base64_encode(pack('H*', md5($password)));
}
}
}
PK D#]V�� � Helper/UUID4.phpnu &1i� <?php
/*
* @package akeebabackup
* @copyright Copyright (c)2006-2020 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU General Public License version 3, or later
*/
namespace Joomla\Plugin\Console\AkeebaBackup\Helper;
defined('_JEXEC') || die;
class UUID4
{
protected $isUpperCase;
public function __construct($isUpperCase = false)
{
$this->isUpperCase = !!$isUpperCase;
}
public function get($sep = '-')
{
$result = '';
// time_low unsigned 32 bit integer
$result .= $this->random(32);
// "-"
$result .= $sep;
// time_mid unsigned 16 bit integer
$result .= $this->random(16);
// "-"
$result .= $sep;
// time_hi_and_version unsigned 16 bit integer
// version (0100)
$result .= $this->hexString(1 << 2, 4);
// time-hi
$result .= $this->random(12);
// "-"
$result .= $sep;
// clock_seq_hi_and_reserved unsigned 8 bit integer
// 10xxxxxx (x is random)
$result .= $this->hexString(1 << 7 | random_int(0, 2 ** 6 - 1), 8);
// clock_seq_low unsigned 8 bit integer
$result .= $this->random(8);
// "-"
$result .= $sep;
// node unsigned 48 bit integer
$result .= $this->random(48);
return $result;
}
protected function random($bitNum)
{
$result = '';
$bits = 16;
$sum = 0;
while ($bitNum != $sum && $bits > 0)
{
$bits = (($bitNum - $sum) > 16) ? 16 : $bitNum - $sum;
$sum += $bits;
$val = random_int(0, 2 ** $bits - 1);
$result = $this->hexString($val, $bits) . $result;
}
return $result;
}
protected function hexString($val, $bits)
{
$digits = (int) ($bits / 4 + 0.9);
return sprintf('%0' . $digits . ($this->isUpperCase ? 'X' : 'x'), $val);
}
}
PK D#] �u u Extension/AkeebaBackup.phpnu &1i� <?php
/*
* @package akeebabackup
* @copyright Copyright (c)2006-2020 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU General Public License version 3, or later
*/
namespace Joomla\Plugin\Console\AkeebaBackup\Extension;
defined('_JEXEC') || die;
use Akeeba\Backup\Admin\Helper\SecretWord;
use Akeeba\Backup\Admin\Model\ControlPanel;
use Akeeba\Engine\Factory;
use Akeeba\Engine\Platform;
use FOF30\Container\Container;
use Joomla\Application\ApplicationEvents;
use Joomla\Application\Event\ApplicationEvent;
use Joomla\CMS\Application\ConsoleApplication;
use Joomla\CMS\Factory as JFactory;
use Joomla\CMS\Filesystem\Folder;
use Joomla\CMS\Plugin\CMSPlugin;
use Joomla\Console\Command\AbstractCommand;
use Joomla\Database\DatabaseDriver;
use Joomla\Event\SubscriberInterface;
use RuntimeException;
use Throwable;
class AkeebaBackup extends CMSPlugin implements SubscriberInterface
{
/**
* Load the language file on instantiation.
*
* @var boolean
* @since 7.5.0
*/
protected $autoloadLanguage = true;
/**
* Application object.
*
* @var ConsoleApplication
* @since 7.5.0
*/
protected $app;
/**
* Returns an array of events this subscriber will listen to.
*
* @return array
*
* @since 7.5.0
*/
public static function getSubscribedEvents(): array
{
return [
ApplicationEvents::BEFORE_EXECUTE => 'registerCLICommands',
];
}
/**
* Registers command classes to the CLI application.
*
* This is an event handled for the ApplicationEvents::BEFORE_EXECUTE event.
*
* @param ApplicationEvent $event The before_execite application event being handled
*
* @since 7.5.0
*/
public function registerCLICommands(ApplicationEvent $event)
{
// Only register CLI commands if we can boot up the Akeeba Backup component enough to make it usable.
try
{
//$this->initialiseComponent();
}
catch (Throwable $e)
{
return;
}
$this->initialiseComponent();
/** @var ConsoleApplication $app */
$app = $event->getApplication();
// Try to find all commands in the CliCommands directory of the component
$baseNamespace = '\Akeeba\Backup\Admin\CliCommands\\';
$files = Folder::files(JPATH_ADMINISTRATOR . '/components/com_akeeba/CliCommands', '.php');
$files = is_array($files) ? $files : [];
foreach ($files as $file)
{
// Construct a fully qualified class name
$className = $baseNamespace . basename($file, '.php');
/**
* Make sure the class exists. Works around hosts renaming/duplicating files with silly extensions like
* .1.php or .disabled.php. We've been seeing that nonsense since as early as 2013.
*/
if (!class_exists($className))
{
continue;
}
// If I can construct the command object add it to the application. Otherwise move to the next file.
try
{
$o = new $className;
if (!($o instanceof AbstractCommand))
{
continue;
}
$app->addCommand($o);
}
catch (Throwable $e)
{
continue;
}
}
}
private function initialiseComponent(): void
{
if (!defined('FOF30_INCLUDED') && !@include_once(JPATH_LIBRARIES . '/fof30/include.php'))
{
throw new RuntimeException('FOF 3.0 is not installed', 500);
}
if (!defined('AKEEBA_CACERT_PEM'))
{
define('AKEEBA_CACERT_PEM', JPATH_LIBRARIES . '/src/Http/Transport/cacert.pem');
}
$container = Container::getInstance('com_akeeba', [], 'admin');
// Load the FOF language
$lang = $container->platform->getLanguage();
$lang->load('lib_fof30', JPATH_ADMINISTRATOR, 'en-GB', true, true);
$lang->load('lib_fof30', JPATH_ADMINISTRATOR, null, true, false);
// Load the Akeeba Backup language files
$lang->load('com_akeeba', JPATH_SITE, 'en-GB', true, true);
$lang->load('com_akeeba', JPATH_SITE, null, true, false);
$lang->load('com_akeeba', JPATH_ADMINISTRATOR, 'en-GB', true, true);
$lang->load('com_akeeba', JPATH_ADMINISTRATOR, null, true, false);
// Necessary for routing the Alice view
$container->inflector->addWord('Alice', 'Alices');
// Load Akeeba Engine
$this->loadAkeebaEngine();
// Load the Akeeba Engine configuration
$retryLoadingEngineConfiguration = false;
try
{
$this->loadAkeebaEngineConfiguration();
}
catch (\Exception $e)
{
// Maybe the tables are not installed?
/** @var ControlPanel $cPanelModel */
$cPanelModel = $container->factory->model('ControlPanel')->tmpInstance();
$cPanelModel->checkAndFixDatabase();
$retryLoadingEngineConfiguration = true;
}
if ($retryLoadingEngineConfiguration)
{
$this->loadAkeebaEngineConfiguration();
}
// Prevents the "SQLSTATE[HY000]: General error: 2014" due to resource sharing with Akeeba Engine
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// !!!!! WARNING: ALWAYS GO THROUGH JFactory; DO NOT GO THROUGH $this->container->db !!!!!
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (version_compare(PHP_VERSION, '7.999.999', 'le'))
{
/** @var DatabaseDriver $jDbo */
$jDbo = JFactory::getContainer()->get('DatabaseDriver');
if ($jDbo->getName() == 'pdomysql')
{
@$jDbo->disconnect();
}
}
// Make sure the front-end backup Secret Word is stored encrypted
$params = $container->params;
SecretWord::enforceEncryption($params, 'frontend_secret_word');
// Make sure we have a version loaded
@include_once($container->backEndPath . '/version.php');
if (!defined('AKEEBA_VERSION'))
{
define('AKEEBA_VERSION', 'dev');
define('AKEEBA_DATE', date('Y-m-d'));
}
}
public function loadAkeebaEngine(): void
{
$container = Container::getInstance('com_akeeba', [], 'admin');
// Necessary defines for Akeeba Engine
if (!defined('AKEEBAENGINE'))
{
define('AKEEBAENGINE', 1);
define('AKEEBAROOT', $container->backEndPath . '/BackupEngine');
}
if (!defined('AKEEBA_BACKUP_ORIGIN'))
{
define('AKEEBA_BACKUP_ORIGIN', 'cli');
}
// Make sure we have a profile set throughout the component's lifetime
$profile_id = $container->platform->getSessionVar('profile', null, 'akeeba');
if (is_null($profile_id))
{
$container->platform->setSessionVar('profile', 1, 'akeeba');
}
// Load Akeeba Engine
$basePath = $container->backEndPath;
require_once $basePath . '/BackupEngine/Factory.php';
}
public function loadAkeebaEngineConfiguration(): void
{
$container = Container::getInstance('com_akeeba', [], 'admin');
Platform::addPlatform('joomla3x', $container->backEndPath . '/BackupPlatform/Joomla3x');
$akeebaEngineConfig = Factory::getConfiguration();
Platform::getInstance()->load_configuration();
unset($akeebaEngineConfig);
}
}
PK n #]*��9 �9 DataSet.phpnu &1i� <?php
/**
* Part of the Joomla Framework Data Package
*
* @copyright Copyright (C) 2005 - 2016 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Data;
/**
* DataSet is a collection class that allows the developer to operate on a set of DataObject objects as if they were in a
* typical PHP array.
*
* @since 1.0
*/
class DataSet implements DumpableInterface, \ArrayAccess, \Countable, \Iterator
{
/**
* The current position of the iterator.
*
* @var integer
* @since 1.0
*/
private $current = false;
/**
* The iterator objects.
*
* @var DataObject[]
* @since 1.0
*/
private $objects = array();
/**
* The class constructor.
*
* @param DataObject[] $objects An array of DataObject objects to bind to the data set.
*
* @since 1.0
* @throws \InvalidArgumentException if an object is not an instance of Data\Object.
*/
public function __construct(array $objects = array())
{
// Set the objects.
$this->_initialise($objects);
}
/**
* The magic call method is used to call object methods using the iterator.
*
* Example: $array = $objectList->foo('bar');
*
* The object list will iterate over its objects and see if each object has a callable 'foo' method.
* If so, it will pass the argument list and assemble any return values. If an object does not have
* a callable method no return value is recorded.
* The keys of the objects and the result array are maintained.
*
* @param string $method The name of the method called.
* @param array $arguments The arguments of the method called.
*
* @return array An array of values returned by the methods called on the objects in the data set.
*
* @since 1.0
*/
public function __call($method, $arguments = array())
{
$return = array();
// Iterate through the objects.
foreach ($this->objects as $key => $object)
{
// Create the object callback.
$callback = array($object, $method);
// Check if the callback is callable.
if (is_callable($callback))
{
// Call the method for the object.
$return[$key] = call_user_func_array($callback, $arguments);
}
}
return $return;
}
/**
* The magic get method is used to get a list of properties from the objects in the data set.
*
* Example: $array = $dataSet->foo;
*
* This will return a column of the values of the 'foo' property in all the objects
* (or values determined by custom property setters in the individual Data\Object's).
* The result array will contain an entry for each object in the list (compared to __call which may not).
* The keys of the objects and the result array are maintained.
*
* @param string $property The name of the data property.
*
* @return array An associative array of the values.
*
* @since 1.0
*/
public function __get($property)
{
$return = array();
// Iterate through the objects.
foreach ($this->objects as $key => $object)
{
// Get the property.
$return[$key] = $object->$property;
}
return $return;
}
/**
* The magic isset method is used to check the state of an object property using the iterator.
*
* Example: $array = isset($objectList->foo);
*
* @param string $property The name of the property.
*
* @return boolean True if the property is set in any of the objects in the data set.
*
* @since 1.0
*/
public function __isset($property)
{
$return = array();
// Iterate through the objects.
foreach ($this->objects as $object)
{
// Check the property.
$return[] = isset($object->$property);
}
return in_array(true, $return, true) ? true : false;
}
/**
* The magic set method is used to set an object property using the iterator.
*
* Example: $objectList->foo = 'bar';
*
* This will set the 'foo' property to 'bar' in all of the objects
* (or a value determined by custom property setters in the Data\Object).
*
* @param string $property The name of the property.
* @param mixed $value The value to give the data property.
*
* @return void
*
* @since 1.0
*/
public function __set($property, $value)
{
// Iterate through the objects.
foreach ($this->objects as $object)
{
// Set the property.
$object->$property = $value;
}
}
/**
* The magic unset method is used to unset an object property using the iterator.
*
* Example: unset($objectList->foo);
*
* This will unset all of the 'foo' properties in the list of Data\Object's.
*
* @param string $property The name of the property.
*
* @return void
*
* @since 1.0
*/
public function __unset($property)
{
// Iterate through the objects.
foreach ($this->objects as $object)
{
unset($object->$property);
}
}
/**
* Gets an array of keys, existing in objects
*
* @param string $type Selection type 'all' or 'common'
*
* @return array Array of keys
*
* @since 1.2.0
* @throws \InvalidArgumentException
*/
public function getObjectsKeys($type = 'all')
{
$keys = null;
if ($type == 'all')
{
$function = 'array_merge';
}
elseif ($type == 'common')
{
$function = 'array_intersect_key';
}
else
{
throw new \InvalidArgumentException("Unknown selection type: $type");
}
foreach ($this->objects as $object)
{
if (version_compare(PHP_VERSION, '5.4.0', '<'))
{
$object_vars = json_decode(json_encode($object->jsonSerialize()), true);
}
else
{
$object_vars = json_decode(json_encode($object), true);
}
$keys = (is_null($keys)) ? $object_vars : $function($keys, $object_vars);
}
return array_keys($keys);
}
/**
* Gets all objects as an array
*
* @param boolean $associative Option to set return mode: associative or numeric array.
* @param string $k Unlimited optional property names to extract from objects.
*
* @return array Returns an array according to defined options.
*
* @since 1.2.0
*/
public function toArray($associative = true, $k = null)
{
$keys = func_get_args();
$associative = array_shift($keys);
if (empty($keys))
{
$keys = $this->getObjectsKeys();
}
$return = array();
$i = 0;
foreach ($this->objects as $key => $object)
{
$array_item = array();
$key = ($associative) ? $key : $i++;
$j = 0;
foreach ($keys as $property)
{
$property_key = ($associative) ? $property : $j++;
$array_item[$property_key] = (isset($object->$property)) ? $object->$property : null;
}
$return[$key] = $array_item;
}
return $return;
}
/**
* Gets the number of data objects in the set.
*
* @return integer The number of objects.
*
* @since 1.0
*/
public function count()
{
return count($this->objects);
}
/**
* Clears the objects in the data set.
*
* @return DataSet Returns itself to allow chaining.
*
* @since 1.0
*/
public function clear()
{
$this->objects = array();
$this->rewind();
return $this;
}
/**
* Get the current data object in the set.
*
* @return DataObject The current object, or false if the array is empty or the pointer is beyond the end of the elements.
*
* @since 1.0
*/
public function current()
{
return is_scalar($this->current) ? $this->objects[$this->current] : false;
}
/**
* Dumps the data object in the set, recursively if appropriate.
*
* @param integer $depth The maximum depth of recursion (default = 3).
* For example, a depth of 0 will return a stdClass with all the properties in native
* form. A depth of 1 will recurse into the first level of properties only.
* @param \SplObjectStorage $dumped An array of already serialized objects that is used to avoid infinite loops.
*
* @return array An associative array of the data objects in the set, dumped as a simple PHP stdClass object.
*
* @see DataObject::dump()
* @since 1.0
*/
public function dump($depth = 3, \SplObjectStorage $dumped = null)
{
// Check if we should initialise the recursion tracker.
if ($dumped === null)
{
$dumped = new \SplObjectStorage;
}
// Add this object to the dumped stack.
$dumped->attach($this);
$objects = array();
// Make sure that we have not reached our maximum depth.
if ($depth > 0)
{
// Handle JSON serialization recursively.
foreach ($this->objects as $key => $object)
{
$objects[$key] = $object->dump($depth, $dumped);
}
}
return $objects;
}
/**
* Gets the data set in a form that can be serialised to JSON format.
*
* Note that this method will not return an associative array, otherwise it would be encoded into an object.
* JSON decoders do not consistently maintain the order of associative keys, whereas they do maintain the order of arrays.
*
* @param mixed $serialized An array of objects that have already been serialized that is used to infinite loops
* (null on first call).
*
* @return array An array that can be serialised by json_encode().
*
* @since 1.0
*/
public function jsonSerialize($serialized = null)
{
// Check if we should initialise the recursion tracker.
if ($serialized === null)
{
$serialized = array();
}
// Add this object to the serialized stack.
$serialized[] = spl_object_hash($this);
$return = array();
// Iterate through the objects.
foreach ($this->objects as $object)
{
// Call the method for the object.
$return[] = $object->jsonSerialize($serialized);
}
return $return;
}
/**
* Gets the key of the current object in the iterator.
*
* @return scalar The object key on success; null on failure.
*
* @since 1.0
*/
public function key()
{
return $this->current;
}
/**
* Gets the array of keys for all the objects in the iterator (emulates array_keys).
*
* @return array The array of keys
*
* @since 1.0
*/
public function keys()
{
return array_keys($this->objects);
}
/**
* Applies a function to every object in the set (emulates array_walk).
*
* @param callable $funcname Callback function.
*
* @return boolean
*
* @since 1.2.0
* @throws \InvalidArgumentException
*/
public function walk($funcname)
{
if (!is_callable($funcname))
{
$message = __METHOD__ . '() expects parameter 1 to be a valid callback';
if (is_string($funcname))
{
$message .= sprintf(', function \'%s\' not found or invalid function name', $funcname);
}
throw new \InvalidArgumentException($message);
}
foreach ($this->objects as $key => $object)
{
$funcname($object, $key);
}
return true;
}
/**
* Advances the iterator to the next object in the iterator.
*
* @return void
*
* @since 1.0
*/
public function next()
{
// Get the object offsets.
$keys = $this->keys();
// Check if _current has been set to false but offsetUnset.
if ($this->current === false && isset($keys[0]))
{
// This is a special case where offsetUnset was used in a foreach loop and the first element was unset.
$this->current = $keys[0];
}
else
{
// Get the current key.
$position = array_search($this->current, $keys);
// Check if there is an object after the current object.
if ($position !== false && isset($keys[$position + 1]))
{
// Get the next id.
$this->current = $keys[$position + 1];
}
else
{
// That was the last object or the internal properties have become corrupted.
$this->current = null;
}
}
}
/**
* Checks whether an offset exists in the iterator.
*
* @param mixed $offset The object offset.
*
* @return boolean True if the object exists, false otherwise.
*
* @since 1.0
*/
public function offsetExists($offset)
{
return isset($this->objects[$offset]);
}
/**
* Gets an offset in the iterator.
*
* @param mixed $offset The object offset.
*
* @return DataObject The object if it exists, null otherwise.
*
* @since 1.0
*/
public function offsetGet($offset)
{
return isset($this->objects[$offset]) ? $this->objects[$offset] : null;
}
/**
* Sets an offset in the iterator.
*
* @param mixed $offset The object offset.
* @param DataObject $object The object object.
*
* @return void
*
* @since 1.0
* @throws \InvalidArgumentException if an object is not an instance of Data\Object.
*/
public function offsetSet($offset, $object)
{
if (!($object instanceof DataObject))
{
throw new \InvalidArgumentException(sprintf('%s("%s", *%s*)', __METHOD__, $offset, gettype($object)));
}
// Set the offset.
$this->objects[$offset] = $object;
}
/**
* Unsets an offset in the iterator.
*
* @param mixed $offset The object offset.
*
* @return void
*
* @since 1.0
*/
public function offsetUnset($offset)
{
if (!$this->offsetExists($offset))
{
// Do nothing if the offset does not exist.
return;
}
// Check for special handling of unsetting the current position.
if ($offset == $this->current)
{
// Get the current position.
$keys = $this->keys();
$position = array_search($this->current, $keys);
// Check if there is an object before the current object.
if ($position > 0)
{
// Move the current position back one.
$this->current = $keys[$position - 1];
}
else
{
// We are at the start of the keys AND let's assume we are in a foreach loop and `next` is going to be called.
$this->current = false;
}
}
unset($this->objects[$offset]);
}
/**
* Rewinds the iterator to the first object.
*
* @return void
*
* @since 1.0
*/
public function rewind()
{
// Set the current position to the first object.
if (empty($this->objects))
{
$this->current = false;
}
else
{
$keys = $this->keys();
$this->current = array_shift($keys);
}
}
/**
* Validates the iterator.
*
* @return boolean True if valid, false otherwise.
*
* @since 1.0
*/
public function valid()
{
// Check the current position.
if (!is_scalar($this->current) || !isset($this->objects[$this->current]))
{
return false;
}
return true;
}
/**
* Initialises the list with an array of objects.
*
* @param array $input An array of objects.
*
* @return void
*
* @since 1.0
* @throws \InvalidArgumentException if an object is not an instance of Data\DataObject.
*/
private function _initialise(array $input = array())
{
foreach ($input as $key => $object)
{
if (!is_null($object))
{
$this->offsetSet($key, $object);
}
}
$this->rewind();
}
}
PK n #]
���! ! DumpableInterface.phpnu &1i� <?php
/**
* Part of the Joomla Framework Data Package
*
* @copyright Copyright (C) 2005 - 2016 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Data;
/**
* An interface to define if an object is dumpable.
*
* @since 1.0
*/
interface DumpableInterface
{
/**
* Dumps the object properties into a stdClass object, recursively if appropriate.
*
* @param integer $depth The maximum depth of recursion.
* For example, a depth of 0 will return a stdClass with all the properties in native
* form. A depth of 1 will recurse into the first level of properties only.
* @param \SplObjectStorage $dumped An array of already serialized objects that is used to avoid infinite loops.
*
* @return \stdClass The data properties as a simple PHP stdClass object.
*
* @since 1.0
*/
public function dump($depth = 3, \SplObjectStorage $dumped = null);
}
PK n #]��`g" g" DataObject.phpnu &1i� <?php
/**
* Part of the Joomla Framework Data Package
*
* @copyright Copyright (C) 2005 - 2016 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Data;
use Joomla\Registry\Registry;
/**
* DataObject is a class that is used to store data but allowing you to access the data
* by mimicking the way PHP handles class properties.
*
* @since 1.0
*/
class DataObject implements DumpableInterface, \IteratorAggregate, \JsonSerializable, \Countable
{
/**
* The data object properties.
*
* @var array
* @since 1.0
*/
private $properties = array();
/**
* The class constructor.
*
* @param mixed $properties Either an associative array or another object
* by which to set the initial properties of the new object.
*
* @since 1.0
* @throws \InvalidArgumentException
*/
public function __construct($properties = array())
{
// Check the properties input.
if (!empty($properties))
{
// Bind the properties.
$this->bind($properties);
}
}
/**
* The magic get method is used to get a data property.
*
* This method is a public proxy for the protected getProperty method.
*
* Note: Magic __get does not allow recursive calls. This can be tricky because the error generated by recursing into
* __get is "Undefined property: {CLASS}::{PROPERTY}" which is misleading. This is relevant for this class because
* requesting a non-visible property can trigger a call to a sub-function. If that references the property directly in
* the object, it will cause a recursion into __get.
*
* @param string $property The name of the data property.
*
* @return mixed The value of the data property, or null if the data property does not exist.
*
* @see DataObject::getProperty()
* @since 1.0
*/
public function __get($property)
{
return $this->getProperty($property);
}
/**
* The magic isset method is used to check the state of an object property.
*
* @param string $property The name of the data property.
*
* @return boolean True if set, otherwise false is returned.
*
* @since 1.0
*/
public function __isset($property)
{
return isset($this->properties[$property]);
}
/**
* The magic set method is used to set a data property.
*
* This is a public proxy for the protected setProperty method.
*
* @param string $property The name of the data property.
* @param mixed $value The value to give the data property.
*
* @return void
*
* @see DataObject::setProperty()
* @since 1.0
*/
public function __set($property, $value)
{
$this->setProperty($property, $value);
}
/**
* The magic unset method is used to unset a data property.
*
* @param string $property The name of the data property.
*
* @return void
*
* @since 1.0
*/
public function __unset($property)
{
unset($this->properties[$property]);
}
/**
* Binds an array or object to this object.
*
* @param mixed $properties An associative array of properties or an object.
* @param boolean $updateNulls True to bind null values, false to ignore null values.
*
* @return DataObject Returns itself to allow chaining.
*
* @since 1.0
* @throws \InvalidArgumentException
*/
public function bind($properties, $updateNulls = true)
{
// Check the properties data type.
if (!is_array($properties) && !is_object($properties))
{
throw new \InvalidArgumentException(sprintf('%s(%s)', __METHOD__, gettype($properties)));
}
// Check if the object is traversable.
if ($properties instanceof \Traversable)
{
// Convert iterator to array.
$properties = iterator_to_array($properties);
}
elseif (is_object($properties))
// Check if the object needs to be converted to an array.
{
// Convert properties to an array.
$properties = (array) $properties;
}
// Bind the properties.
foreach ($properties as $property => $value)
{
// Check if the value is null and should be bound.
if ($value === null && !$updateNulls)
{
continue;
}
// Set the property.
$this->setProperty($property, $value);
}
return $this;
}
/**
* Dumps the data properties into a stdClass object, recursively if appropriate.
*
* @param integer $depth The maximum depth of recursion (default = 3).
* For example, a depth of 0 will return a stdClass with all the properties in native
* form. A depth of 1 will recurse into the first level of properties only.
* @param \SplObjectStorage $dumped An array of already serialized objects that is used to avoid infinite loops.
*
* @return \stdClass The data properties as a simple PHP stdClass object.
*
* @since 1.0
*/
public function dump($depth = 3, \SplObjectStorage $dumped = null)
{
// Check if we should initialise the recursion tracker.
if ($dumped === null)
{
$dumped = new \SplObjectStorage;
}
// Add this object to the dumped stack.
$dumped->attach($this);
// Setup a container.
$dump = new \stdClass;
// Dump all object properties.
foreach (array_keys($this->properties) as $property)
{
// Get the property.
$dump->$property = $this->dumpProperty($property, $depth, $dumped);
}
return $dump;
}
/**
* Gets this object represented as an ArrayIterator.
*
* This allows the data properties to be access via a foreach statement.
*
* @return \ArrayIterator This object represented as an ArrayIterator.
*
* @see IteratorAggregate::getIterator()
* @since 1.0
*/
public function getIterator()
{
return new \ArrayIterator($this->dump(0));
}
/**
* Gets the data properties in a form that can be serialised to JSON format.
*
* @return string An object that can be serialised by json_encode().
*
* @since 1.0
*/
public function jsonSerialize()
{
return $this->dump();
}
/**
* Dumps a data property.
*
* If recursion is set, this method will dump any object implementing Data\Dumpable (like Data\Object and Data\Set); it will
* convert a Date object to a string; and it will convert a Registry to an object.
*
* @param string $property The name of the data property.
* @param integer $depth The current depth of recursion (a value of 0 will ignore recursion).
* @param \SplObjectStorage $dumped An array of already serialized objects that is used to avoid infinite loops.
*
* @return mixed The value of the dumped property.
*
* @since 1.0
*/
protected function dumpProperty($property, $depth, \SplObjectStorage $dumped)
{
$value = $this->getProperty($property);
if ($depth > 0)
{
// Check if the object is also an dumpable object.
if ($value instanceof DumpableInterface)
{
// Do not dump the property if it has already been dumped.
if (!$dumped->contains($value))
{
$value = $value->dump($depth - 1, $dumped);
}
}
// Check if the object is a date.
if ($value instanceof \DateTime)
{
$value = $value->format('Y-m-d H:i:s');
}
elseif ($value instanceof Registry)
// Check if the object is a registry.
{
$value = $value->toObject();
}
}
return $value;
}
/**
* Gets a data property.
*
* @param string $property The name of the data property.
*
* @return mixed The value of the data property.
*
* @see DataObject::__get()
* @since 1.0
*/
protected function getProperty($property)
{
// Get the raw value.
$value = array_key_exists($property, $this->properties) ? $this->properties[$property] : null;
return $value;
}
/**
* Sets a data property.
*
* If the name of the property starts with a null byte, this method will return null.
*
* @param string $property The name of the data property.
* @param mixed $value The value to give the data property.
*
* @return mixed The value of the data property.
*
* @see DataObject::__set()
* @since 1.0
*/
protected function setProperty($property, $value)
{
/*
* Check if the property starts with a null byte. If so, discard it because a later attempt to try to access it
* can cause a fatal error. See http://us3.php.net/manual/en/language.types.array.php#language.types.array.casting
*/
if (strpos($property, "\0") === 0)
{
return null;
}
// Set the value.
$this->properties[$property] = $value;
return $value;
}
/**
* Count the number of data properties.
*
* @return integer The number of data properties.
*
* @since 1.0
*/
public function count()
{
return count($this->properties);
}
}
PK � #]��� � ContainerAwareTrait.phpnu &1i� <?php
/**
* Part of the Joomla Framework DI Package
*
* @copyright Copyright (C) 2013 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\DI;
/**
* Defines the trait for a Container Aware Class.
*
* @since 1.2
* @note Traits are available in PHP 5.4+
*/
trait ContainerAwareTrait
{
/**
* DI Container
*
* @var Container
* @since 1.2
*/
private $container;
/**
* Get the DI container.
*
* @return Container
*
* @since 1.2
* @throws \UnexpectedValueException May be thrown if the container has not been set.
* @note As of 2.0 this method will be protected.
*/
public function getContainer()
{
if ($this->container)
{
return $this->container;
}
throw new \UnexpectedValueException('Container not set in ' . __CLASS__);
}
/**
* Set the DI container.
*
* @param Container $container The DI container.
*
* @return mixed Returns itself to support chaining.
*
* @since 1.2
*/
public function setContainer(Container $container)
{
$this->container = $container;
return $this;
}
}
PK � #]�B B ContainerAwareInterface.phpnu &1i� <?php
/**
* Part of the Joomla Framework DI Package
*
* @copyright Copyright (C) 2013 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\DI;
/**
* Defines the interface for a Container Aware class.
*
* @since 1.0
*/
interface ContainerAwareInterface
{
/**
* Get the DI container.
*
* @return Container
*
* @since 1.0
* @throws \UnexpectedValueException May be thrown if the container has not been set.
* @deprecated 2.0 The getter will no longer be part of the interface.
*/
public function getContainer();
/**
* Set the DI container.
*
* @param Container $container The DI container.
*
* @return mixed
*
* @since 1.0
*/
public function setContainer(Container $container);
}
PK � #]��$� � " Exception/KeyNotFoundException.phpnu &1i� <?php
/**
* Part of the Joomla Framework DI Package
*
* @copyright Copyright (C) 2013 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\DI\Exception;
use Psr\Container\NotFoundExceptionInterface;
/**
* No entry was found in the container.
*
* @since 1.5.0
*/
class KeyNotFoundException extends \InvalidArgumentException implements NotFoundExceptionInterface
{
}
PK � #]���� � # Exception/ProtectedKeyException.phpnu &1i� <?php
/**
* Part of the Joomla Framework DI Package
*
* @copyright Copyright (C) 2013 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\DI\Exception;
use Psr\Container\ContainerExceptionInterface;
/**
* Attempt to set the value of a protected key, which already is set
*
* @since 1.5.0
*/
class ProtectedKeyException extends \OutOfBoundsException implements ContainerExceptionInterface
{
}
PK � #]y�q� � + Exception/DependencyResolutionException.phpnu &1i� <?php
/**
* Part of the Joomla Framework DI Package
*
* @copyright Copyright (C) 2013 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\DI\Exception;
use Psr\Container\ContainerExceptionInterface;
/**
* Exception class for handling errors in resolving a dependency
*
* @since 1.0
*/
class DependencyResolutionException extends \RuntimeException implements ContainerExceptionInterface
{
}
PK � #]�td�? ? ServiceProviderInterface.phpnu &1i� <?php
/**
* Part of the Joomla Framework DI Package
*
* @copyright Copyright (C) 2013 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\DI;
/**
* Defines the interface for a Service Provider.
*
* @since 1.0
*/
interface ServiceProviderInterface
{
/**
* Registers the service provider with a DI container.
*
* @param Container $container The DI container.
*
* @return void
*
* @since 1.0
*/
public function register(Container $container);
}
PK � #]֬gsp5 p5
Container.phpnu &1i� <?php
/**
* Part of the Joomla Framework DI Package
*
* @copyright Copyright (C) 2013 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\DI;
use Joomla\DI\Exception\DependencyResolutionException;
use Joomla\DI\Exception\KeyNotFoundException;
use Joomla\DI\Exception\ProtectedKeyException;
use Psr\Container\ContainerInterface;
/**
* The Container class.
*
* @since 1.0
*/
class Container implements ContainerInterface
{
/**
* Holds the key aliases.
*
* @var array
* @since 1.0
*/
protected $aliases = array();
/**
* Holds the shared instances.
*
* @var array
* @since 1.0
*/
protected $instances = array();
/**
* Holds the keys, their callbacks, and whether or not
* the item is meant to be a shared resource.
*
* @var array
* @since 1.0
*/
protected $dataStore = array();
/**
* Parent for hierarchical containers.
*
* @var Container|ContainerInterface
* @since 1.0
*/
protected $parent;
/**
* Holds the service tag mapping.
*
* @var array
* @since 1.5.0
*/
protected $tags = array();
/**
* Constructor for the DI Container
*
* @param ContainerInterface $parent Parent for hierarchical containers.
*
* @since 1.0
*/
public function __construct(ContainerInterface $parent = null)
{
$this->parent = $parent;
}
/**
* Create an alias for a given key for easy access.
*
* @param string $alias The alias name
* @param string $key The key to alias
*
* @return Container This object for chaining.
*
* @since 1.0
*/
public function alias($alias, $key)
{
$this->aliases[$alias] = $key;
return $this;
}
/**
* Search the aliases property for a matching alias key.
*
* @param string $key The key to search for.
*
* @return string
*
* @since 1.0
*/
protected function resolveAlias($key)
{
if (isset($this->aliases[$key]))
{
return $this->aliases[$key];
}
if ($this->parent instanceof Container)
{
return $this->parent->resolveAlias($key);
}
return $key;
}
/**
* Assign a tag to services.
*
* @param string $tag The tag name
* @param array $keys The service keys to tag
*
* @return Container This object for chaining.
*
* @since 1.5.0
*/
public function tag($tag, array $keys)
{
foreach ($keys as $key)
{
$resolvedKey = $this->resolveAlias($key);
if (!isset($this->tags[$tag]))
{
$this->tags[$tag] = array();
}
$this->tags[$tag][] = $resolvedKey;
}
// Prune duplicates
$this->tags[$tag] = array_unique($this->tags[$tag]);
return $this;
}
/**
* Fetch all services registered to the given tag.
*
* @param string $tag The tag name
*
* @return array The resolved services for the given tag
*
* @since 1.5.0
*/
public function getTagged($tag)
{
$services = array();
if (isset($this->tags[$tag]))
{
foreach ($this->tags[$tag] as $service)
{
$services[] = $this->get($service);
}
}
return $services;
}
/**
* Build an object of class $key;
*
* @param string $key The class name to build.
* @param boolean $shared True to create a shared resource.
*
* @return object|false Instance of class specified by $key with all dependencies injected.
* Returns an object if the class exists and false otherwise
*
* @since 1.0
*/
public function buildObject($key, $shared = false)
{
static $buildStack = array();
$resolvedKey = $this->resolveAlias($key);
if (in_array($resolvedKey, $buildStack, true))
{
$buildStack = array();
throw new DependencyResolutionException("Can't resolve circular dependency");
}
$buildStack[] = $resolvedKey;
if ($this->has($resolvedKey))
{
$resource = $this->get($resolvedKey);
array_pop($buildStack);
return $resource;
}
try
{
$reflection = new \ReflectionClass($resolvedKey);
}
catch (\ReflectionException $e)
{
array_pop($buildStack);
return false;
}
if (!$reflection->isInstantiable())
{
$buildStack = array();
throw new DependencyResolutionException("$resolvedKey can not be instantiated.");
}
$constructor = $reflection->getConstructor();
// If there are no parameters, just return a new object.
if ($constructor === null)
{
$callback = function () use ($resolvedKey) {
return new $resolvedKey;
};
}
else
{
$newInstanceArgs = $this->getMethodArgs($constructor);
// Create a callable for the dataStore
$callback = function () use ($reflection, $newInstanceArgs) {
return $reflection->newInstanceArgs($newInstanceArgs);
};
}
$this->set($resolvedKey, $callback, $shared);
$resource = $this->get($resolvedKey);
array_pop($buildStack);
return $resource;
}
/**
* Convenience method for building a shared object.
*
* @param string $key The class name to build.
*
* @return object|false Instance of class specified by $key with all dependencies injected.
* Returns an object if the class exists and false otherwise
*
* @since 1.0
*/
public function buildSharedObject($key)
{
return $this->buildObject($key, true);
}
/**
* Create a child Container with a new property scope that
* that has the ability to access the parent scope when resolving.
*
* @return Container This object for chaining.
*
* @since 1.0
*/
public function createChild()
{
return new static($this);
}
/**
* Extend a defined service Closure by wrapping the existing one with a new Closure. This
* works very similar to a decorator pattern. Note that this only works on service Closures
* that have been defined in the current Provider, not parent providers.
*
* @param string $key The unique identifier for the Closure or property.
* @param \Closure $callable A Closure to wrap the original service Closure.
*
* @return void
*
* @since 1.0
* @throws KeyNotFoundException
*/
public function extend($key, \Closure $callable)
{
$key = $this->resolveAlias($key);
$raw = $this->getRaw($key);
if ($raw === null)
{
throw new KeyNotFoundException(sprintf('The requested key %s does not exist to extend.', $key));
}
$closure = function ($c) use ($callable, $raw) {
return $callable($raw['callback']($c), $c);
};
$this->set($key, $closure, $raw['shared']);
}
/**
* Build an array of constructor parameters.
*
* @param \ReflectionMethod $method Method for which to build the argument array.
*
* @return array Array of arguments to pass to the method.
*
* @since 1.0
* @throws DependencyResolutionException
*/
protected function getMethodArgs(\ReflectionMethod $method)
{
$methodArgs = array();
foreach ($method->getParameters() as $param)
{
$dependency = $param->getClass();
$dependencyVarName = $param->getName();
// If we have a dependency, that means it has been type-hinted.
if ($dependency !== null)
{
$dependencyClassName = $dependency->getName();
// If the dependency class name is registered with this container or a parent, use it.
if ($this->getRaw($dependencyClassName) !== null)
{
$depObject = $this->get($dependencyClassName);
}
else
{
$depObject = $this->buildObject($dependencyClassName);
}
if ($depObject instanceof $dependencyClassName)
{
$methodArgs[] = $depObject;
continue;
}
}
// Finally, if there is a default parameter, use it.
if ($param->isOptional())
{
$methodArgs[] = $param->getDefaultValue();
continue;
}
// Couldn't resolve dependency, and no default was provided.
throw new DependencyResolutionException(sprintf('Could not resolve dependency: %s', $dependencyVarName));
}
return $methodArgs;
}
/**
* Method to set the key and callback to the dataStore array.
*
* @param string $key Name of dataStore key to set.
* @param mixed $value Callable function to run or string to retrive when requesting the specified $key.
* @param boolean $shared True to create and store a shared instance.
* @param boolean $protected True to protect this item from being overwritten. Useful for services.
*
* @return Container This object for chaining.
*
* @since 1.0
* @throws ProtectedKeyException Thrown if the provided key is already set and is protected.
*/
public function set($key, $value, $shared = false, $protected = false)
{
if (isset($this->dataStore[$key]) && $this->dataStore[$key]['protected'] === true)
{
throw new ProtectedKeyException(sprintf("Key %s is protected and can't be overwritten.", $key));
}
// If the provided $value is not a closure, make it one now for easy resolution.
if (!is_callable($value))
{
$value = function () use ($value) {
return $value;
};
}
$this->dataStore[$key] = array(
'callback' => $value,
'shared' => $shared,
'protected' => $protected
);
return $this;
}
/**
* Convenience method for creating protected keys.
*
* @param string $key Name of dataStore key to set.
* @param mixed $value Callable function to run or string to retrive when requesting the specified $key.
* @param boolean $shared True to create and store a shared instance.
*
* @return Container This object for chaining.
*
* @since 1.0
*/
public function protect($key, $value, $shared = false)
{
return $this->set($key, $value, $shared, true);
}
/**
* Convenience method for creating shared keys.
*
* @param string $key Name of dataStore key to set.
* @param mixed $value Callable function to run or string to retrive when requesting the specified $key.
* @param boolean $protected True to protect this item from being overwritten. Useful for services.
*
* @return Container This object for chaining.
*
* @since 1.0
*/
public function share($key, $value, $protected = false)
{
return $this->set($key, $value, true, $protected);
}
/**
* Method to retrieve the results of running the $callback for the specified $key;
*
* @param string $key Name of the dataStore key to get.
* @param boolean $forceNew True to force creation and return of a new instance.
*
* @return mixed Results of running the $callback for the specified $key.
*
* @since 1.0
* @throws KeyNotFoundException
*/
public function get($key, $forceNew = false)
{
$key = $this->resolveAlias($key);
$raw = $this->getRaw($key);
if ($raw === null)
{
throw new KeyNotFoundException(sprintf('Key %s has not been registered with the container.', $key));
}
if ($raw['shared'])
{
if ($forceNew || !isset($this->instances[$key]))
{
$this->instances[$key] = $raw['callback']($this);
}
return $this->instances[$key];
}
return call_user_func($raw['callback'], $this);
}
/**
* Method to check if specified dataStore key exists.
*
* @param string $key Name of the dataStore key to check.
*
* @return boolean True for success
*
* @since 1.5.0
*/
public function has($key)
{
$key = $this->resolveAlias($key);
$exists = (bool) $this->getRaw($key);
if ($exists === false && $this->parent instanceof ContainerInterface)
{
$exists = $this->parent->has($key);
}
return $exists;
}
/**
* Method to check if specified dataStore key exists.
*
* @param string $key Name of the dataStore key to check.
*
* @return boolean True for success
*
* @since 1.0
* @deprecated 3.0 Use ContainerInterface::has() instead
*/
public function exists($key)
{
return $this->has($key);
}
/**
* Get the raw data assigned to a key.
*
* @param string $key The key for which to get the stored item.
*
* @return mixed
*
* @since 1.0
*/
protected function getRaw($key)
{
if (isset($this->dataStore[$key]))
{
return $this->dataStore[$key];
}
$aliasKey = $this->resolveAlias($key);
if ($aliasKey !== $key && isset($this->dataStore[$aliasKey]))
{
return $this->dataStore[$aliasKey];
}
if ($this->parent instanceof Container)
{
return $this->parent->getRaw($key);
}
if ($this->parent instanceof ContainerInterface && $this->parent->has($key))
{
$callback = $this->parent->get($key);
if (!is_callable($callback))
{
$callback = function () use ($callback) {
return $callback;
};
}
return array(
'callback' => $callback,
'shared' => true,
'protected' => true,
);
}
return null;
}
/**
* Method to force the container to return a new instance
* of the results of the callback for requested $key.
*
* @param string $key Name of the dataStore key to get.
*
* @return mixed Results of running the $callback for the specified $key.
*
* @since 1.0
*/
public function getNewInstance($key)
{
return $this->get($key, true);
}
/**
* Register a service provider to the container.
*
* @param ServiceProviderInterface $provider The service provider to register.
*
* @return Container This object for chaining.
*
* @since 1.0
*/
public function registerServiceProvider(ServiceProviderInterface $provider)
{
$provider->register($this);
return $this;
}
/**
* Retrieve the keys for services assigned to this container.
*
* @return array
*
* @since 1.5.0
*/
public function getKeys()
{
return array_unique(array_merge(array_keys($this->aliases), array_keys($this->dataStore)));
}
}
PK � #],����
�
ImageFilter.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
/**
* Class to manipulate an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
abstract class ImageFilter implements LoggerAwareInterface
{
/**
* @var resource|\GdImage The image resource handle.
* @since 1.0
*/
protected $handle;
/**
* @var LoggerInterface Logger object
* @since 1.0
*/
protected $logger;
/**
* Class constructor.
*
* @param resource|\GdImage $handle The image resource on which to apply the filter.
*
* @since 1.0
* @throws \InvalidArgumentException
* @throws \RuntimeException
*/
public function __construct($handle)
{
// Verify that image filter support for PHP is available.
if (!\function_exists('imagefilter'))
{
// @codeCoverageIgnoreStart
$this->getLogger()->error('The imagefilter function for PHP is not available.');
throw new \RuntimeException('The imagefilter function for PHP is not available.');
// @codeCoverageIgnoreEnd
}
// Make sure the file handle is valid.
if (!$this->isValidImage($handle))
{
$this->getLogger()->error('The image handle is invalid for the image filter.');
throw new \InvalidArgumentException('The image handle is invalid for the image filter.');
}
$this->handle = $handle;
}
/**
* Get the logger.
*
* @return LoggerInterface
*
* @since 1.0
*/
public function getLogger()
{
// If a logger hasn't been set, use NullLogger
if (! ($this->logger instanceof LoggerInterface))
{
$this->logger = new NullLogger;
}
return $this->logger;
}
/**
* Sets a logger instance on the object
*
* @param LoggerInterface $logger A PSR-3 compliant logger.
*
* @return ImageFilter This object for message chaining.
*
* @since 1.0
*/
public function setLogger(LoggerInterface $logger)
{
$this->logger = $logger;
return $this;
}
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
*/
abstract public function execute(array $options = array());
/**
* @param mixed $handle A potential image handle
*
* @return boolean
*/
private function isValidImage($handle)
{
// @todo Remove resource check, once PHP7 support is dropped.
return (\is_resource($handle) && \get_resource_type($handle) === 'gd')
|| (\is_object($handle) && $handle instanceof \GDImage);
}
}
PK � #]*W�� Filter/Negate.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use Joomla\Image\ImageFilter;
/**
* Image Filter class to negate the colors of an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Negate extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
*/
public function execute(array $options = array())
{
// Perform the negative filter.
imagefilter($this->handle, IMG_FILTER_NEGATE);
}
}
PK � #]�
� � Filter/Emboss.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use Joomla\Image\ImageFilter;
/**
* Image Filter class to emboss an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Emboss extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
*/
public function execute(array $options = array())
{
// Perform the emboss filter.
imagefilter($this->handle, IMG_FILTER_EMBOSS);
}
}
PK � #]�LE Filter/Sketchy.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use Joomla\Image\ImageFilter;
/**
* Image Filter class to make an image appear "sketchy".
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Sketchy extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
*/
public function execute(array $options = array())
{
// Perform the sketchy filter.
imagefilter($this->handle, IMG_FILTER_MEAN_REMOVAL);
}
}
PK � #] �f�� � Filter/Brightness.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use InvalidArgumentException;
use Joomla\Image\ImageFilter;
/**
* Image Filter class adjust the brightness of an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Brightness extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
* @throws InvalidArgumentException
*/
public function execute(array $options = array())
{
// Validate that the brightness value exists and is an integer.
if (!isset($options[IMG_FILTER_BRIGHTNESS]) || !\is_int($options[IMG_FILTER_BRIGHTNESS]))
{
throw new InvalidArgumentException('No valid brightness value was given. Expected integer.');
}
// Perform the brightness filter.
imagefilter($this->handle, IMG_FILTER_BRIGHTNESS, $options[IMG_FILTER_BRIGHTNESS]);
}
}
PK � #]e�E $ $ Filter/Edgedetect.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use Joomla\Image\ImageFilter;
/**
* Image Filter class to add an edge detect effect to an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Edgedetect extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
*/
public function execute(array $options = array())
{
// Perform the edge detection filter.
imagefilter($this->handle, IMG_FILTER_EDGEDETECT);
}
}
PK � #]�SUp�
�
Filter/Backgroundfill.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use InvalidArgumentException;
use Joomla\Image\ImageFilter;
/**
* Image Filter class fill background with color;
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Backgroundfill extends ImageFilter
{
/**
* Method to apply a background color to an image resource.
*
* @param array $options An array of options for the filter.
* color Background matte color
*
* @return void
*
* @since 1.0
* @throws InvalidArgumentException
*/
public function execute(array $options = array())
{
// Validate that the color value exists and is an integer.
if (!isset($options['color']))
{
throw new InvalidArgumentException('No color value was given. Expected string or array.');
}
$colorCode = (!empty($options['color'])) ? $options['color'] : null;
// Get resource dimensions
$width = imagesx($this->handle);
$height = imagesy($this->handle);
// Sanitize color
$rgba = $this->sanitizeColor($colorCode);
// Enforce alpha on source image
if (imageistruecolor($this->handle))
{
imagealphablending($this->handle, false);
imagesavealpha($this->handle, true);
}
// Create background
$bg = imagecreatetruecolor($width, $height);
imagesavealpha($bg, empty($rgba['alpha']));
// Allocate background color.
$color = imagecolorallocatealpha($bg, $rgba['red'], $rgba['green'], $rgba['blue'], $rgba['alpha']);
// Fill background
imagefill($bg, 0, 0, $color);
// Apply image over background
imagecopy($bg, $this->handle, 0, 0, 0, 0, $width, $height);
// Move flattened result onto curent handle.
// If handle was palette-based, it'll stay like that.
imagecopy($this->handle, $bg, 0, 0, 0, 0, $width, $height);
// Free up memory
imagedestroy($bg);
}
/**
* Method to sanitize color values
* and/or convert to an array
*
* @param mixed $input Associative array of colors and alpha,
* or hex RGBA string when alpha FF is opaque.
* Defaults to black and opaque alpha
*
* @return array Associative array of red, green, blue and alpha
*
* @since 1.0
*
* @note '#FF0000FF' returns an array with alpha of 0 (opaque)
*/
protected function sanitizeColor($input)
{
// Construct default values
$colors = array('red' => 0, 'green' => 0, 'blue' => 0, 'alpha' => 0);
// Make sure all values are in
if (\is_array($input))
{
$colors = array_merge($colors, $input);
}
elseif (\is_string($input))
{
// Convert RGBA 6-9 char string
$hex = ltrim($input, '#');
$hexValues = array(
'red' => substr($hex, 0, 2),
'green' => substr($hex, 2, 2),
'blue' => substr($hex, 4, 2),
'alpha' => substr($hex, 6, 2),
);
$colors = array_map('hexdec', $hexValues);
// Convert Alpha to 0..127 when provided
if (\strlen($hex) > 6)
{
$colors['alpha'] = floor((255 - $colors['alpha']) / 2);
}
}
else
{
// Cannot sanitize such type
return $colors;
}
// Make sure each value is within the allowed range
foreach ($colors as &$value)
{
$value = max(0, min(255, (int) $value));
}
$colors['alpha'] = min(127, $colors['alpha']);
return $colors;
}
}
PK � #]�� Filter/Grayscale.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use Joomla\Image\ImageFilter;
/**
* Image Filter class to transform an image to grayscale.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Grayscale extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
*/
public function execute(array $options = array())
{
// Perform the grayscale filter.
imagefilter($this->handle, IMG_FILTER_GRAYSCALE);
}
}
PK � #]җ��p p Filter/Smooth.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use InvalidArgumentException;
use Joomla\Image\ImageFilter;
/**
* Image Filter class adjust the smoothness of an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Smooth extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
* @throws InvalidArgumentException
*/
public function execute(array $options = array())
{
// Validate that the smoothing value exists and is an integer.
if (!isset($options[IMG_FILTER_SMOOTH]) || !\is_int($options[IMG_FILTER_SMOOTH]))
{
throw new InvalidArgumentException('No valid smoothing value was given. Expected integer.');
}
// Perform the smoothing filter.
imagefilter($this->handle, IMG_FILTER_SMOOTH, $options[IMG_FILTER_SMOOTH]);
}
}
PK � #]�=c�u u Filter/Contrast.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image\Filter;
use InvalidArgumentException;
use Joomla\Image\ImageFilter;
/**
* Image Filter class adjust the contrast of an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Contrast extends ImageFilter
{
/**
* Method to apply a filter to an image resource.
*
* @param array $options An array of options for the filter.
*
* @return void
*
* @since 1.0
* @throws InvalidArgumentException
*/
public function execute(array $options = array())
{
// Validate that the contrast value exists and is an integer.
if (!isset($options[IMG_FILTER_CONTRAST]) || !\is_int($options[IMG_FILTER_CONTRAST]))
{
throw new InvalidArgumentException('No valid contrast value was given. Expected integer.');
}
// Perform the contrast filter.
imagefilter($this->handle, IMG_FILTER_CONTRAST, $options[IMG_FILTER_CONTRAST]);
}
}
PK � #]�^M(| (| Image.phpnu &1i� <?php
/**
* Part of the Joomla Framework Image Package
*
* @copyright Copyright (C) 2005 - 2018 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Image;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
/**
* Class to manipulate an image.
*
* @since 1.0
* @deprecated The joomla/image package is deprecated
*/
class Image implements LoggerAwareInterface
{
/**
* @const integer
* @since 1.0
*/
const SCALE_FILL = 1;
/**
* @const integer
* @since 1.0
*/
const SCALE_INSIDE = 2;
/**
* @const integer
* @since 1.0
*/
const SCALE_OUTSIDE = 3;
/**
* @const integer
* @since 1.0
*/
const CROP = 4;
/**
* @const integer
* @since 1.0
*/
const CROP_RESIZE = 5;
/**
* @const integer
* @since 1.0
*/
const SCALE_FIT = 6;
/**
* @const string
* @since 1.2.0
*/
const ORIENTATION_LANDSCAPE = 'landscape';
/**
* @const string
* @since 1.2.0
*/
const ORIENTATION_PORTRAIT = 'portrait';
/**
* @const string
* @since 1.2.0
*/
const ORIENTATION_SQUARE = 'square';
/**
* @var resource|\GdImage The image resource handle.
* @since 1.0
*/
protected $handle;
/**
* @var string The source image path.
* @since 1.0
*/
protected $path;
/**
* @var array Whether or not different image formats are supported.
* @since 1.0
*/
protected static $formats = array();
/**
* @var LoggerInterface Logger object
* @since 1.0
*/
protected $logger;
/**
* @var boolean Flag if an image should use the best quality available. Disable for improved performance.
* @since 1.4.0
*/
protected $generateBestQuality = true;
/**
* Class constructor.
*
* @param mixed $source Either a file path for a source image or a GD resource handler for an image.
*
* @since 1.0
* @throws \RuntimeException
*/
public function __construct($source = null)
{
// Verify that GD support for PHP is available.
if (!\extension_loaded('gd'))
{
// @codeCoverageIgnoreStart
throw new \RuntimeException('The GD extension for PHP is not available.');
// @codeCoverageIgnoreEnd
}
// Determine which image types are supported by GD, but only once.
if (!isset(static::$formats[IMAGETYPE_JPEG]))
{
$info = gd_info();
static::$formats[IMAGETYPE_JPEG] = ($info['JPEG Support']) ? true : false;
static::$formats[IMAGETYPE_PNG] = ($info['PNG Support']) ? true : false;
static::$formats[IMAGETYPE_GIF] = ($info['GIF Read Support']) ? true : false;
}
// If the source input is a resource, set it as the image handle.
if ($this->isValidImage($source))
{
$this->handle = &$source;
}
elseif (!empty($source) && \is_string($source))
{
// If the source input is not empty, assume it is a path and populate the image handle.
$this->loadFile($source);
}
}
/**
* Get the image resource handle
*
* @return resource
*
* @since 1.3.0
* @throws \LogicException if an image has not been loaded into the instance
*/
public function getHandle()
{
// Make sure the resource handle is valid.
if (!$this->isLoaded())
{
throw new \LogicException('No valid image was loaded.');
}
return $this->handle;
}
/**
* Get the logger.
*
* @return LoggerInterface
*
* @since 1.0
*/
public function getLogger()
{
// If a logger hasn't been set, use NullLogger
if (! ($this->logger instanceof LoggerInterface))
{
$this->logger = new NullLogger;
}
return $this->logger;
}
/**
* Sets a logger instance on the object
*
* @param LoggerInterface $logger A PSR-3 compliant logger.
*
* @return Image This object for message chaining.
*
* @since 1.0
*/
public function setLogger(LoggerInterface $logger)
{
$this->logger = $logger;
return $this;
}
/**
* Method to return a properties object for an image given a filesystem path.
*
* The result object has values for image width, height, type, attributes, mime type, bits, and channels.
*
* @param string $path The filesystem path to the image for which to get properties.
*
* @return \stdClass
*
* @since 1.0
* @throws \InvalidArgumentException
* @throws \RuntimeException
*/
public static function getImageFileProperties($path)
{
// Make sure the file exists.
if (!file_exists($path))
{
throw new \InvalidArgumentException('The image file does not exist.');
}
// Get the image file information.
$info = getimagesize($path);
if (!$info)
{
// @codeCoverageIgnoreStart
throw new \RuntimeException('Unable to get properties for the image.');
// @codeCoverageIgnoreEnd
}
// Build the response object.
$properties = (object) array(
'width' => $info[0],
'height' => $info[1],
'type' => $info[2],
'attributes' => $info[3],
'bits' => isset($info['bits']) ? $info['bits'] : null,
'channels' => isset($info['channels']) ? $info['channels'] : null,
'mime' => $info['mime'],
'filesize' => filesize($path),
'orientation' => self::getOrientationString((int) $info[0], (int) $info[1]),
);
return $properties;
}
/**
* Method to detect whether an image's orientation is landscape, portrait or square.
*
* The orientation will be returned as a string.
*
* @return mixed Orientation string or null.
*
* @since 1.2.0
*/
public function getOrientation()
{
if ($this->isLoaded())
{
return self::getOrientationString($this->getWidth(), $this->getHeight());
}
}
/**
* Compare width and height integers to determine image orientation.
*
* @param integer $width The width value to use for calculation
* @param integer $height The height value to use for calculation
*
* @return string Orientation string
*
* @since 1.2.0
*/
private static function getOrientationString($width, $height)
{
switch (true)
{
case $width > $height :
return self::ORIENTATION_LANDSCAPE;
case $width < $height :
return self::ORIENTATION_PORTRAIT;
default:
return self::ORIENTATION_SQUARE;
}
}
/**
* Method to generate thumbnails from the current image. It allows
* creation by resizing or cropping the original image.
*
* @param mixed $thumbSizes String or array of strings. Example: $thumbSizes = array('150x75','250x150');
* @param integer $creationMethod 1-3 resize $scaleMethod | 4 create cropping | 5 resize then crop
*
* @return array
*
* @since 1.0
* @throws \LogicException
* @throws \InvalidArgumentException
*/
public function generateThumbs($thumbSizes, $creationMethod = self::SCALE_INSIDE)
{
// Make sure the resource handle is valid.
if (!$this->isLoaded())
{
throw new \LogicException('No valid image was loaded.');
}
// Accept a single thumbsize string as parameter
if (!\is_array($thumbSizes))
{
$thumbSizes = array($thumbSizes);
}
// Process thumbs
$generated = array();
if (!empty($thumbSizes))
{
foreach ($thumbSizes as $thumbSize)
{
// Desired thumbnail size
$size = explode('x', strtolower($thumbSize));
if (\count($size) != 2)
{
throw new \InvalidArgumentException('Invalid thumb size received: ' . $thumbSize);
}
$thumbWidth = $size[0];
$thumbHeight = $size[1];
switch ($creationMethod)
{
// Crop
case self::CROP:
$thumb = $this->crop($thumbWidth, $thumbHeight, null, null, true);
break;
// Crop-resize
case self::CROP_RESIZE:
$thumb = $this->cropResize($thumbWidth, $thumbHeight, true);
break;
default:
$thumb = $this->resize($thumbWidth, $thumbHeight, true, $creationMethod);
break;
}
// Store the thumb in the results array
$generated[] = $thumb;
}
}
return $generated;
}
/**
* Method to create thumbnails from the current image and save them to disk. It allows creation by resizing
* or cropping the original image.
*
* @param mixed $thumbSizes string or array of strings. Example: $thumbSizes = array('150x75','250x150');
* @param integer $creationMethod 1-3 resize $scaleMethod | 4 create cropping
* @param string $thumbsFolder destination thumbs folder. null generates a thumbs folder in the image folder
*
* @return array
*
* @since 1.0
* @throws \LogicException
* @throws \InvalidArgumentException
*/
public function createThumbs($thumbSizes, $creationMethod = self::SCALE_INSIDE, $thumbsFolder = null)
{
// Make sure the resource handle is valid.
if (!$this->isLoaded())
{
throw new \LogicException('No valid image was loaded.');
}
// No thumbFolder set -> we will create a thumbs folder in the current image folder
if ($thumbsFolder === null)
{
$thumbsFolder = \dirname($this->getPath()) . '/thumbs';
}
// Check destination
if (!is_dir($thumbsFolder) && (!is_dir(\dirname($thumbsFolder)) || !@mkdir($thumbsFolder)))
{
throw new \InvalidArgumentException('Folder does not exist and cannot be created: ' . $thumbsFolder);
}
// Process thumbs
$thumbsCreated = array();
if ($thumbs = $this->generateThumbs($thumbSizes, $creationMethod))
{
// Parent image properties
$imgProperties = static::getImageFileProperties($this->getPath());
foreach ($thumbs as $thumb)
{
// Get thumb properties
$thumbWidth = $thumb->getWidth();
$thumbHeight = $thumb->getHeight();
// Generate thumb name
$filename = pathinfo($this->getPath(), PATHINFO_FILENAME);
$fileExtension = pathinfo($this->getPath(), PATHINFO_EXTENSION);
$thumbFileName = $filename . '_' . $thumbWidth . 'x' . $thumbHeight . '.' . $fileExtension;
// Save thumb file to disk
$thumbFileName = $thumbsFolder . '/' . $thumbFileName;
if ($thumb->toFile($thumbFileName, $imgProperties->type))
{
// Return Image object with thumb path to ease further manipulation
$thumb->path = $thumbFileName;
$thumbsCreated[] = $thumb;
}
}
}
return $thumbsCreated;
}
/**
* Method to crop the current image.
*
* @param mixed $width The width of the image section to crop in pixels or a percentage.
* @param mixed $height The height of the image section to crop in pixels or a percentage.
* @param integer $left The number of pixels from the left to start cropping.
* @param integer $top The number of pixels from the top to start cropping.
* @param boolean $createNew If true the current image will be cloned, cropped and returned; else
* the current image will be cropped and returned.
*
* @return Image
*
* @since 1.0
* @throws \LogicException
*/
public function crop($width, $height, $left = null, $top = null, $createNew = true)
{
// Sanitize width.
$width = $this->sanitizeWidth($width, $height);
// Sanitize height.
$height = $this->sanitizeHeight($height, $width);
// Autocrop offsets
if ($left === null)
{
$left = round(($this->getWidth() - $width) / 2);
}
if ($top === null)
{
$top = round(($this->getHeight() - $height) / 2);
}
// Sanitize left.
$left = $this->sanitizeOffset($left);
// Sanitize top.
$top = $this->sanitizeOffset($top);
// Create the new truecolor image handle.
$handle = imagecreatetruecolor($width, $height);
// Allow transparency for the new image handle.
imagealphablending($handle, false);
imagesavealpha($handle, true);
if ($this->isTransparent())
{
// Get the transparent color values for the current image.
$rgba = imagecolorsforindex($this->getHandle(), imagecolortransparent($this->getHandle()));
$color = imagecolorallocatealpha($handle, $rgba['red'], $rgba['green'], $rgba['blue'], $rgba['alpha']);
// Set the transparent color values for the new image.
imagecolortransparent($handle, $color);
imagefill($handle, 0, 0, $color);
}
if (!$this->generateBestQuality)
{
imagecopyresized($handle, $this->getHandle(), 0, 0, $left, $top, $width, $height, $width, $height);
}
else
{
imagecopyresampled($handle, $this->getHandle(), 0, 0, $left, $top, $width, $height, $width, $height);
}
// If we are cropping to a new image, create a new Image object.
if ($createNew)
{
// @codeCoverageIgnoreStart
return new static($handle);
// @codeCoverageIgnoreEnd
}
// Swap out the current handle for the new image handle.
$this->destroy();
$this->handle = $handle;
return $this;
}
/**
* Method to apply a filter to the image by type. Two examples are: grayscale and sketchy.
*
* @param string $type The name of the image filter to apply.
* @param array $options An array of options for the filter.
*
* @return Image
*
* @since 1.0
* @see Joomla\Image\Filter
* @throws \LogicException
*/
public function filter($type, array $options = array())
{
// Make sure the resource handle is valid.
if (!$this->isLoaded())
{
throw new \LogicException('No valid image was loaded.');
}
// Get the image filter instance.
$filter = $this->getFilterInstance($type);
// Execute the image filter.
$filter->execute($options);
return $this;
}
/**
* Method to get the height of the image in pixels.
*
* @return integer
*
* @since 1.0
* @throws \LogicException
*/
public function getHeight()
{
return imagesy($this->getHandle());
}
/**
* Method to get the width of the image in pixels.
*
* @return integer
*
* @since 1.0
* @throws \LogicException
*/
public function getWidth()
{
return imagesx($this->getHandle());
}
/**
* Method to return the path
*
* @return string
*
* @since 1.0
*/
public function getPath()
{
return $this->path;
}
/**
* Method to determine whether or not an image has been loaded into the object.
*
* @return boolean
*
* @since 1.0
*/
public function isLoaded()
{
// Make sure the resource handle is valid.
return $this->isValidImage($this->handle);
}
/**
* Method to determine whether or not the image has transparency.
*
* @return boolean
*
* @since 1.0
* @throws \LogicException
*/
public function isTransparent()
{
return imagecolortransparent($this->getHandle()) >= 0;
}
/**
* Method to load a file into the Image object as the resource.
*
* @param string $path The filesystem path to load as an image.
*
* @return void
*
* @since 1.0
* @throws \InvalidArgumentException
* @throws \RuntimeException
*/
public function loadFile($path)
{
// Destroy the current image handle if it exists
$this->destroy();
// Make sure the file exists.
if (!file_exists($path))
{
throw new \InvalidArgumentException('The image file does not exist.');
}
// Get the image properties.
$properties = static::getImageFileProperties($path);
// Attempt to load the image based on the MIME-Type
switch ($properties->mime)
{
case 'image/gif':
// Make sure the image type is supported.
if (empty(static::$formats[IMAGETYPE_GIF]))
{
// @codeCoverageIgnoreStart
$this->getLogger()->error('Attempting to load an image of unsupported type GIF.');
throw new \RuntimeException('Attempting to load an image of unsupported type GIF.');
// @codeCoverageIgnoreEnd
}
// Attempt to create the image handle.
$handle = imagecreatefromgif($path);
if (!$this->isValidImage($handle))
{
// @codeCoverageIgnoreStart
throw new \RuntimeException('Unable to process GIF image.');
// @codeCoverageIgnoreEnd
}
$this->handle = $handle;
break;
case 'image/jpeg':
// Make sure the image type is supported.
if (empty(static::$formats[IMAGETYPE_JPEG]))
{
// @codeCoverageIgnoreStart
$this->getLogger()->error('Attempting to load an image of unsupported type JPG.');
throw new \RuntimeException('Attempting to load an image of unsupported type JPG.');
// @codeCoverageIgnoreEnd
}
// Attempt to create the image handle.
$handle = imagecreatefromjpeg($path);
if (!$this->isValidImage($handle))
{
// @codeCoverageIgnoreStart
throw new \RuntimeException('Unable to process JPG image.');
// @codeCoverageIgnoreEnd
}
$this->handle = $handle;
break;
case 'image/png':
// Make sure the image type is supported.
if (empty(static::$formats[IMAGETYPE_PNG]))
{
// @codeCoverageIgnoreStart
$this->getLogger()->error('Attempting to load an image of unsupported type PNG.');
throw new \RuntimeException('Attempting to load an image of unsupported type PNG.');
// @codeCoverageIgnoreEnd
}
// Attempt to create the image handle.
$handle = imagecreatefrompng($path);
if (!$this->isValidImage($handle))
{
// @codeCoverageIgnoreStart
throw new \RuntimeException('Unable to process PNG image.');
// @codeCoverageIgnoreEnd
}
$this->handle = $handle;
break;
default:
$this->getLogger()->error('Attempting to load an image of unsupported type ' . $properties->mime);
throw new \InvalidArgumentException('Attempting to load an image of unsupported type ' . $properties->mime);
}
// Set the filesystem path to the source image.
$this->path = $path;
}
/**
* Method to resize the current image.
*
* @param mixed $width The width of the resized image in pixels or a percentage.
* @param mixed $height The height of the resized image in pixels or a percentage.
* @param boolean $createNew If true the current image will be cloned, resized and returned; else
* the current image will be resized and returned.
* @param integer $scaleMethod Which method to use for scaling
*
* @return Image
*
* @since 1.0
* @throws \LogicException
*/
public function resize($width, $height, $createNew = true, $scaleMethod = self::SCALE_INSIDE)
{
// Sanitize width.
$width = $this->sanitizeWidth($width, $height);
// Sanitize height.
$height = $this->sanitizeHeight($height, $width);
// Prepare the dimensions for the resize operation.
$dimensions = $this->prepareDimensions($width, $height, $scaleMethod);
// Instantiate offset.
$offset = new \stdClass;
$offset->x = $offset->y = 0;
// Center image if needed and create the new truecolor image handle.
if ($scaleMethod == self::SCALE_FIT)
{
// Get the offsets
$offset->x = round(($width - $dimensions->width) / 2);
$offset->y = round(($height - $dimensions->height) / 2);
$handle = imagecreatetruecolor($width, $height);
// Make image transparent, otherwise canvas outside initial image would default to black
if (!$this->isTransparent())
{
$transparency = imagecolorallocatealpha($this->getHandle(), 0, 0, 0, 127);
imagecolortransparent($this->getHandle(), $transparency);
}
}
else
{
$handle = imagecreatetruecolor($dimensions->width, $dimensions->height);
}
// Allow transparency for the new image handle.
imagealphablending($handle, false);
imagesavealpha($handle, true);
if ($this->isTransparent())
{
// Get the transparent color values for the current image.
$rgba = imagecolorsforindex($this->getHandle(), imagecolortransparent($this->getHandle()));
$color = imagecolorallocatealpha($handle, $rgba['red'], $rgba['green'], $rgba['blue'], $rgba['alpha']);
// Set the transparent color values for the new image.
imagecolortransparent($handle, $color);
imagefill($handle, 0, 0, $color);
}
if (!$this->generateBestQuality)
{
imagecopyresized(
$handle,
$this->getHandle(),
$offset->x,
$offset->y,
0,
0,
$dimensions->width,
$dimensions->height,
$this->getWidth(),
$this->getHeight()
);
}
else
{
// Use resampling for better quality
imagecopyresampled(
$handle,
$this->getHandle(),
$offset->x,
$offset->y,
0,
0,
$dimensions->width,
$dimensions->height,
$this->getWidth(),
$this->getHeight()
);
}
// If we are resizing to a new image, create a new JImage object.
if ($createNew)
{
// @codeCoverageIgnoreStart
return new static($handle);
// @codeCoverageIgnoreEnd
}
// Swap out the current handle for the new image handle.
$this->destroy();
$this->handle = $handle;
return $this;
}
/**
* Method to crop an image after resizing it to maintain
* proportions without having to do all the set up work.
*
* @param integer $width The desired width of the image in pixels or a percentage.
* @param integer $height The desired height of the image in pixels or a percentage.
* @param integer $createNew If true the current image will be cloned, resized, cropped and returned.
*
* @return Image
*
* @since 1.0
*/
public function cropResize($width, $height, $createNew = true)
{
$width = $this->sanitizeWidth($width, $height);
$height = $this->sanitizeHeight($height, $width);
$resizewidth = $width;
$resizeheight = $height;
if (($this->getWidth() / $width) < ($this->getHeight() / $height))
{
$resizeheight = 0;
}
else
{
$resizewidth = 0;
}
return $this->resize($resizewidth, $resizeheight, $createNew)->crop($width, $height, null, null, false);
}
/**
* Method to rotate the current image.
*
* @param mixed $angle The angle of rotation for the image
* @param integer $background The background color to use when areas are added due to rotation
* @param boolean $createNew If true the current image will be cloned, rotated and returned; else
* the current image will be rotated and returned.
*
* @return Image
*
* @since 1.0
* @throws \LogicException
*/
public function rotate($angle, $background = -1, $createNew = true)
{
// Sanitize input
$angle = (float) $angle;
// Create the new truecolor image handle.
$handle = imagecreatetruecolor($this->getWidth(), $this->getHeight());
// Make background transparent if no external background color is provided.
if ($background == -1)
{
// Allow transparency for the new image handle.
imagealphablending($handle, false);
imagesavealpha($handle, true);
$background = imagecolorallocatealpha($handle, 0, 0, 0, 127);
}
// Copy the image
imagecopy($handle, $this->getHandle(), 0, 0, 0, 0, $this->getWidth(), $this->getHeight());
// Rotate the image
$handle = imagerotate($handle, $angle, $background);
// If we are resizing to a new image, create a new Image object.
if ($createNew)
{
// @codeCoverageIgnoreStart
return new static($handle);
// @codeCoverageIgnoreEnd
}
// Swap out the current handle for the new image handle.
$this->destroy();
$this->handle = $handle;
return $this;
}
/**
* Method to flip the current image.
*
* @param integer $mode The flip mode for flipping the image {@link https://www.php.net/imageflip#refsect1-function.imageflip-parameters}
* @param boolean $createNew If true the current image will be cloned, flipped and returned; else
* the current image will be flipped and returned.
*
* @return Image
*
* @since 1.2.0
* @throws \LogicException
*/
public function flip($mode, $createNew = true)
{
// Create the new truecolor image handle.
$handle = imagecreatetruecolor($this->getWidth(), $this->getHeight());
// Copy the image
imagecopy($handle, $this->getHandle(), 0, 0, 0, 0, $this->getWidth(), $this->getHeight());
// Flip the image
if (!imageflip($handle, $mode))
{
throw new \LogicException('Unable to flip the image.');
}
// If we are resizing to a new image, create a new Image object.
if ($createNew)
{
// @codeCoverageIgnoreStart
return new static($handle);
// @codeCoverageIgnoreEnd
}
// Free the memory from the current handle
$this->destroy();
// Swap out the current handle for the new image handle.
$this->handle = $handle;
return $this;
}
/**
* Watermark the image
*
* @param Image $watermark The Image object containing the watermark graphic
* @param integer $transparency The transparency to use for the watermark graphic
* @param integer $bottomMargin The margin from the bottom of this image
* @param integer $rightMargin The margin from the right side of this image
*
* @return Image
*
* @since 1.3.0
* @link https://www.php.net/manual/en/image.examples-watermark.php
*/
public function watermark(Image $watermark, $transparency = 50, $bottomMargin = 0, $rightMargin = 0)
{
imagecopymerge(
$this->getHandle(),
$watermark->getHandle(),
$this->getWidth() - $watermark->getWidth() - $rightMargin,
$this->getHeight() - $watermark->getHeight() - $bottomMargin,
0,
0,
$watermark->getWidth(),
$watermark->getHeight(),
$transparency
);
return $this;
}
/**
* Method to write the current image out to a file or output directly.
*
* @param mixed $path The filesystem path to save the image.
* When null, the raw image stream will be outputted directly.
* @param integer $type The image type to save the file as.
* @param array $options The image type options to use in saving the file.
* For PNG and JPEG formats use `quality` key to set compression level (0..9 and 0..100)
*
* @return boolean
*
* @link https://www.php.net/manual/image.constants.php
* @since 1.0
* @throws \LogicException
*/
public function toFile($path, $type = IMAGETYPE_JPEG, array $options = array())
{
switch ($type)
{
case IMAGETYPE_GIF:
return imagegif($this->getHandle(), $path);
case IMAGETYPE_PNG:
return imagepng($this->getHandle(), $path, (array_key_exists('quality', $options)) ? $options['quality'] : 0);
}
// Case IMAGETYPE_JPEG & default
return imagejpeg($this->getHandle(), $path, (array_key_exists('quality', $options)) ? $options['quality'] : 100);
}
/**
* Method to get an image filter instance of a specified type.
*
* @param string $type The image filter type to get.
*
* @return ImageFilter
*
* @since 1.0
* @throws \RuntimeException
*/
protected function getFilterInstance($type)
{
// Sanitize the filter type.
$type = strtolower(preg_replace('#[^A-Z0-9_]#i', '', $type));
// Verify that the filter type exists.
$className = 'Joomla\\Image\\Filter\\' . ucfirst($type);
if (!class_exists($className))
{
$this->getLogger()->error('The ' . ucfirst($type) . ' image filter is not available.');
throw new \RuntimeException('The ' . ucfirst($type) . ' image filter is not available.');
}
// Instantiate the filter object.
$instance = new $className($this->getHandle());
// Verify that the filter type is valid.
if (!($instance instanceof ImageFilter))
{
// @codeCoverageIgnoreStart
$this->getLogger()->error('The ' . ucfirst($type) . ' image filter is not valid.');
throw new \RuntimeException('The ' . ucfirst($type) . ' image filter is not valid.');
// @codeCoverageIgnoreEnd
}
return $instance;
}
/**
* Method to get the new dimensions for a resized image.
*
* @param integer $width The width of the resized image in pixels.
* @param integer $height The height of the resized image in pixels.
* @param integer $scaleMethod The method to use for scaling
*
* @return \stdClass
*
* @since 1.0
* @throws \InvalidArgumentException If width, height or both given as zero
*/
protected function prepareDimensions($width, $height, $scaleMethod)
{
// Instantiate variables.
$dimensions = new \stdClass;
switch ($scaleMethod)
{
case self::SCALE_FILL:
$dimensions->width = (int) round($width);
$dimensions->height = (int) round($height);
break;
case self::SCALE_INSIDE:
case self::SCALE_OUTSIDE:
case self::SCALE_FIT:
$rx = ($width > 0) ? ($this->getWidth() / $width) : 0;
$ry = ($height > 0) ? ($this->getHeight() / $height) : 0;
if ($scaleMethod != self::SCALE_OUTSIDE)
{
$ratio = max($rx, $ry);
}
else
{
$ratio = min($rx, $ry);
}
$dimensions->width = (int) round($this->getWidth() / $ratio);
$dimensions->height = (int) round($this->getHeight() / $ratio);
break;
default:
throw new \InvalidArgumentException('Invalid scale method.');
}
return $dimensions;
}
/**
* Method to sanitize a height value.
*
* @param mixed $height The input height value to sanitize.
* @param mixed $width The input width value for reference.
*
* @return integer
*
* @since 1.0
*/
protected function sanitizeHeight($height, $width)
{
// If no height was given we will assume it is a square and use the width.
$height = ($height === null) ? $width : $height;
// If we were given a percentage, calculate the integer value.
if (preg_match('/^[0-9]+(\.[0-9]+)?\%$/', $height))
{
$height = (int) round($this->getHeight() * (float) str_replace('%', '', $height) / 100);
}
else
{
// Else do some rounding so we come out with a sane integer value.
$height = (int) round((float) $height);
}
return $height;
}
/**
* Method to sanitize an offset value like left or top.
*
* @param mixed $offset An offset value.
*
* @return integer
*
* @since 1.0
*/
protected function sanitizeOffset($offset)
{
return (int) round((float) $offset);
}
/**
* Method to sanitize a width value.
*
* @param mixed $width The input width value to sanitize.
* @param mixed $height The input height value for reference.
*
* @return integer
*
* @since 1.0
*/
protected function sanitizeWidth($width, $height)
{
// If no width was given we will assume it is a square and use the height.
$width = ($width === null) ? $height : $width;
// If we were given a percentage, calculate the integer value.
if (preg_match('/^[0-9]+(\.[0-9]+)?\%$/', $width))
{
$width = (int) round($this->getWidth() * (float) str_replace('%', '', $width) / 100);
}
else
{
// Else do some rounding so we come out with a sane integer value.
$width = (int) round((float) $width);
}
return $width;
}
/**
* Method to destroy an image handle and free the memory associated with the handle
*
* @return boolean True on success, false on failure or if no image is loaded
*
* @since 1.0
*/
public function destroy()
{
if ($this->isLoaded())
{
return imagedestroy($this->getHandle());
}
return false;
}
/**
* Method to call the destroy() method one last time to free any memory when the object is unset
*
* @see Image::destroy()
* @since 1.0
*/
public function __destruct()
{
$this->destroy();
}
/**
* Method for set option of generate thumbnail method
*
* @param boolean $quality True for best quality. False for best speed.
*
* @return void
*
* @since 1.4.0
*/
public function setThumbnailGenerate($quality = true)
{
$this->generateBestQuality = (boolean) $quality;
}
/**
* @param mixed $handle A potential image handle
*
* @return boolean
*/
private function isValidImage($handle)
{
// @todo Remove resource check, once PHP7 support is dropped.
return (\is_resource($handle) && \get_resource_type($handle) === 'gd')
|| (\is_object($handle) && $handle instanceof \GDImage);
}
}
PK x'#]�{�% �% Input.phpnu &1i� <?php
/**
* Part of the Joomla Framework Input Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Input;
use Joomla\Filter;
/**
* Joomla! Input Base Class
*
* This is an abstracted input class used to manage retrieving data from the application environment.
*
* @since 1.0
*
* @property-read Input $get
* @property-read Input $post
* @property-read Input $request
* @property-read Input $server
* @property-read Input $env
* @property-read Files $files
* @property-read Cookie $cookie
*
* @method integer getInt($name, $default = null) Get a signed integer.
* @method integer getUint($name, $default = null) Get an unsigned integer.
* @method float getFloat($name, $default = null) Get a floating-point number.
* @method boolean getBool($name, $default = null) Get a boolean value.
* @method string getWord($name, $default = null) Get a word.
* @method string getAlnum($name, $default = null) Get an alphanumeric string.
* @method string getCmd($name, $default = null) Get a CMD filtered string.
* @method string getBase64($name, $default = null) Get a base64 encoded string.
* @method string getString($name, $default = null) Get a string.
* @method string getHtml($name, $default = null) Get a HTML string.
* @method string getPath($name, $default = null) Get a file path.
* @method string getUsername($name, $default = null) Get a username.
*/
class Input implements \Serializable, \Countable
{
/**
* Container with allowed superglobals
*
* @var array
* @since 1.3.0
* @note Once PHP 7.1 is the minimum supported version this should become a private constant
*/
private static $allowedGlobals = array('REQUEST', 'GET', 'POST', 'FILES', 'SERVER', 'ENV');
/**
* Options array for the Input instance.
*
* @var array
* @since 1.0
*/
protected $options = array();
/**
* Filter object to use.
*
* @var Filter\InputFilter
* @since 1.0
*/
protected $filter;
/**
* Input data.
*
* @var array
* @since 1.0
*/
protected $data = array();
/**
* Input objects
*
* @var Input[]
* @since 1.0
*/
protected $inputs = array();
/**
* Is all GLOBAL added
*
* @var boolean
* @since 1.1.4
*/
protected static $loaded = false;
/**
* Constructor.
*
* @param array $source Optional source data. If omitted, a copy of the server variable '_REQUEST' is used.
* @param array $options An optional associative array of configuration parameters:
* filter: An instance of Filter\Input. If omitted, a default filter is initialised.
*
* @since 1.0
*/
public function __construct($source = null, array $options = array())
{
if (isset($options['filter']))
{
$this->filter = $options['filter'];
}
else
{
$this->filter = new Filter\InputFilter;
}
if ($source === null)
{
$this->data = &$_REQUEST;
}
else
{
$this->data = $source;
}
// Set the options for the class.
$this->options = $options;
}
/**
* Magic method to get an input object
*
* @param mixed $name Name of the input object to retrieve.
*
* @return Input The request input object
*
* @since 1.0
*/
public function __get($name)
{
if (isset($this->inputs[$name]))
{
return $this->inputs[$name];
}
$className = '\\Joomla\\Input\\' . ucfirst($name);
if (class_exists($className))
{
$this->inputs[$name] = new $className(null, $this->options);
return $this->inputs[$name];
}
$superGlobal = '_' . strtoupper($name);
if (\in_array(strtoupper($name), self::$allowedGlobals, true) && isset($GLOBALS[$superGlobal]))
{
$this->inputs[$name] = new Input($GLOBALS[$superGlobal], $this->options);
return $this->inputs[$name];
}
// TODO throw an exception
}
/**
* Get the number of variables.
*
* @return integer The number of variables in the input.
*
* @since 1.0
* @see Countable::count()
*/
public function count()
{
return \count($this->data);
}
/**
* Gets a value from the input data.
*
* @param string $name Name of the value to get.
* @param mixed $default Default value to return if variable does not exist.
* @param string $filter Filter to apply to the value.
*
* @return mixed The filtered input value.
*
* @see \Joomla\Filter\InputFilter::clean()
* @since 1.0
*/
public function get($name, $default = null, $filter = 'cmd')
{
if (isset($this->data[$name]))
{
return $this->filter->clean($this->data[$name], $filter);
}
return $default;
}
/**
* Gets an array of values from the request.
*
* @param array $vars Associative array of keys and filter types to apply.
* If empty and datasource is null, all the input data will be returned
* but filtered using the default case in JFilterInput::clean.
* @param mixed $datasource Array to retrieve data from, or null
*
* @return mixed The filtered input data.
*
* @since 1.0
*/
public function getArray(array $vars = array(), $datasource = null)
{
if (empty($vars) && $datasource === null)
{
$vars = $this->data;
}
$results = array();
foreach ($vars as $k => $v)
{
if (\is_array($v))
{
if ($datasource === null)
{
$results[$k] = $this->getArray($v, $this->get($k, null, 'array'));
}
else
{
$results[$k] = $this->getArray($v, $datasource[$k]);
}
}
else
{
if ($datasource === null)
{
$results[$k] = $this->get($k, null, $v);
}
elseif (isset($datasource[$k]))
{
$results[$k] = $this->filter->clean($datasource[$k], $v);
}
else
{
$results[$k] = $this->filter->clean(null, $v);
}
}
}
return $results;
}
/**
* Get the Input instance holding the data for the current request method
*
* @return Input
*
* @since 1.3.0
*/
public function getInputForRequestMethod()
{
switch (strtoupper($this->getMethod()))
{
case 'GET':
return $this->get;
case 'POST':
return $this->post;
default:
// PUT, PATCH, etc. don't have superglobals
return $this;
}
}
/**
* Sets a value
*
* @param string $name Name of the value to set.
* @param mixed $value Value to assign to the input.
*
* @return void
*
* @since 1.0
*/
public function set($name, $value)
{
$this->data[$name] = $value;
}
/**
* Define a value. The value will only be set if there's no value for the name or if it is null.
*
* @param string $name Name of the value to define.
* @param mixed $value Value to assign to the input.
*
* @return void
*
* @since 1.0
*/
public function def($name, $value)
{
if (isset($this->data[$name]))
{
return;
}
$this->data[$name] = $value;
}
/**
* Check if a value name exists.
*
* @param string $name Value name
*
* @return boolean
*
* @since 1.2.0
*/
public function exists($name)
{
return isset($this->data[$name]);
}
/**
* Magic method to get filtered input data.
*
* @param string $name Name of the filter type prefixed with 'get'.
* @param array $arguments [0] The name of the variable [1] The default value.
*
* @return mixed The filtered input value.
*
* @since 1.0
*/
public function __call($name, $arguments)
{
if (substr($name, 0, 3) == 'get')
{
$filter = substr($name, 3);
$default = null;
if (isset($arguments[1]))
{
$default = $arguments[1];
}
return $this->get($arguments[0], $default, $filter);
}
}
/**
* Gets the request method.
*
* @return string The request method.
*
* @since 1.0
*/
public function getMethod()
{
$method = strtoupper($_SERVER['REQUEST_METHOD']);
return $method;
}
/**
* Method to serialize the input.
*
* @return string The serialized input.
*
* @since 1.0
*/
public function serialize()
{
// Load all of the inputs.
$this->loadAllInputs();
// Remove $_ENV and $_SERVER from the inputs.
$inputs = $this->inputs;
unset($inputs['env'], $inputs['server']);
// Serialize the options, data, and inputs.
return serialize(array($this->options, $this->data, $inputs));
}
/**
* Method to unserialize the input.
*
* @param string $input The serialized input.
*
* @return void
*
* @since 1.0
*/
public function unserialize($input)
{
// Unserialize the options, data, and inputs.
list($this->options, $this->data, $this->inputs) = unserialize($input);
// Load the filter.
if (isset($this->options['filter']))
{
$this->filter = $this->options['filter'];
}
else
{
$this->filter = new Filter\InputFilter;
}
}
/**
* Method to load all of the global inputs.
*
* @return void
*
* @since 1.0
*/
protected function loadAllInputs()
{
if (!self::$loaded)
{
// Load up all the globals.
foreach ($GLOBALS as $global => $data)
{
// Check if the global starts with an underscore and is allowed.
if (strpos($global, '_') === 0 && \in_array(substr($global, 1), self::$allowedGlobals, true))
{
// Convert global name to input name.
$global = strtolower($global);
$global = substr($global, 1);
// Get the input.
$this->$global;
}
}
self::$loaded = true;
}
}
}
PK x'#]2Fh� � Cli.phpnu &1i� <?php
/**
* Part of the Joomla Framework Input Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Input;
use Joomla\Filter;
/**
* Joomla! Input CLI Class
*
* @since 1.0
* @deprecated 2.0 Use a Symfony\Component\Console\Input\InputInterface implementation when using the `joomla/console` package
*/
class Cli extends Input
{
/**
* The executable that was called to run the CLI script.
*
* @var string
* @since 1.0
*/
public $executable;
/**
* The additional arguments passed to the script that are not associated
* with a specific argument name.
*
* @var array
* @since 1.0
*/
public $args = array();
/**
* Constructor.
*
* @param array $source Source data (Optional, default is $_REQUEST)
* @param array $options Array of configuration parameters (Optional)
*
* @since 1.0
*/
public function __construct($source = null, array $options = array())
{
if (isset($options['filter']))
{
$this->filter = $options['filter'];
}
else
{
$this->filter = new Filter\InputFilter;
}
// Get the command line options
$this->parseArguments();
// Set the options for the class.
$this->options = $options;
}
/**
* Method to serialize the input.
*
* @return string The serialized input.
*
* @since 1.0
*/
public function serialize()
{
// Load all of the inputs.
$this->loadAllInputs();
// Remove $_ENV and $_SERVER from the inputs.
$inputs = $this->inputs;
unset($inputs['env'], $inputs['server']);
// Serialize the executable, args, options, data, and inputs.
return serialize(array($this->executable, $this->args, $this->options, $this->data, $inputs));
}
/**
* Gets a value from the input data.
*
* @param string $name Name of the value to get.
* @param mixed $default Default value to return if variable does not exist.
* @param string $filter Filter to apply to the value.
*
* @return mixed The filtered input value.
*
* @since 1.0
*/
public function get($name, $default = null, $filter = 'string')
{
return parent::get($name, $default, $filter);
}
/**
* Method to unserialize the input.
*
* @param string $input The serialized input.
*
* @return void
*
* @since 1.0
*/
public function unserialize($input)
{
// Unserialize the executable, args, options, data, and inputs.
list($this->executable, $this->args, $this->options, $this->data, $this->inputs) = unserialize($input);
// Load the filter.
if (isset($this->options['filter']))
{
$this->filter = $this->options['filter'];
}
else
{
$this->filter = new Filter\InputFilter;
}
}
/**
* Initialise the options and arguments
*
* Not supported: -abc c-value
*
* @return void
*
* @since 1.0
*/
protected function parseArguments()
{
$argv = $_SERVER['argv'];
$this->executable = array_shift($argv);
$out = array();
for ($i = 0, $j = \count($argv); $i < $j; $i++)
{
$arg = $argv[$i];
// --foo --bar=baz
if (substr($arg, 0, 2) === '--')
{
$eqPos = strpos($arg, '=');
// --foo
if ($eqPos === false)
{
$key = substr($arg, 2);
// --foo value
if ($i + 1 < $j && $argv[$i + 1][0] !== '-')
{
$value = $argv[$i + 1];
$i++;
}
else
{
$value = isset($out[$key]) ? $out[$key] : true;
}
$out[$key] = $value;
}
// --bar=baz
else
{
$key = substr($arg, 2, $eqPos - 2);
$value = substr($arg, $eqPos + 1);
$out[$key] = $value;
}
}
// -k=value -abc
elseif (substr($arg, 0, 1) === '-')
{
// -k=value
if (substr($arg, 2, 1) === '=')
{
$key = substr($arg, 1, 1);
$value = substr($arg, 3);
$out[$key] = $value;
}
// -abc
else
{
$chars = str_split(substr($arg, 1));
foreach ($chars as $char)
{
$key = $char;
$value = isset($out[$key]) ? $out[$key] : true;
$out[$key] = $value;
}
// -a a-value
if ((\count($chars) === 1) && ($i + 1 < $j) && ($argv[$i + 1][0] !== '-'))
{
$out[$key] = $argv[$i + 1];
$i++;
}
}
}
// Plain-arg
else
{
$this->args[] = $arg;
}
}
$this->data = $out;
}
}
PK x'#]h� � Json.phpnu &1i� <?php
/**
* Part of the Joomla Framework Input Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Input;
use Joomla\Filter;
/**
* Joomla! Input JSON Class
*
* This class decodes a JSON string from the raw request data and makes it available via
* the standard Input interface.
*
* @since 1.0
*/
class Json extends Input
{
/**
* @var string The raw JSON string from the request.
* @since 1.0
*/
private $raw;
/**
* Constructor.
*
* @param array $source Source data (Optional, default is the raw HTTP input decoded from JSON)
* @param array $options Array of configuration parameters (Optional)
*
* @since 1.0
*/
public function __construct($source = null, array $options = array())
{
if (isset($options['filter']))
{
$this->filter = $options['filter'];
}
else
{
$this->filter = new Filter\InputFilter;
}
if ($source === null)
{
$this->raw = file_get_contents('php://input');
// This is a workaround for where php://input has already been read.
// See note under php://input on https://www.php.net/manual/en/wrappers.php.php
if (empty($this->raw) && isset($GLOBALS['HTTP_RAW_POST_DATA']))
{
$this->raw = $GLOBALS['HTTP_RAW_POST_DATA'];
}
$this->data = json_decode($this->raw, true);
if (!\is_array($this->data))
{
$this->data = array();
}
}
else
{
$this->data = $source;
}
// Set the options for the class.
$this->options = $options;
}
/**
* Gets the raw JSON string from the request.
*
* @return string The raw JSON string from the request.
*
* @since 1.0
*/
public function getRaw()
{
return $this->raw;
}
}
PK x'#]/g���
�
Cookie.phpnu &1i� <?php
/**
* Part of the Joomla Framework Input Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Input;
use Joomla\Filter;
/**
* Joomla! Input Cookie Class
*
* @since 1.0
*/
class Cookie extends Input
{
/**
* Constructor.
*
* @param array $source Ignored.
* @param array $options Array of configuration parameters (Optional)
*
* @since 1.0
*/
public function __construct($source = null, array $options = array())
{
if (isset($options['filter']))
{
$this->filter = $options['filter'];
}
else
{
$this->filter = new Filter\InputFilter;
}
// Set the data source.
$this->data = & $_COOKIE;
// Set the options for the class.
$this->options = $options;
}
/**
* Sets a value
*
* @param string $name Name of the value to set.
* @param mixed $value Value to assign to the input.
* @param array $options An associative array which may have any of the keys expires, path, domain,
* secure, httponly and samesite. The values have the same meaning as described
* for the parameters with the same name. The value of the samesite element
* should be either Lax or Strict. If any of the allowed options are not given,
* their default values are the same as the default values of the explicit
* parameters. If the samesite element is omitted, no SameSite cookie attribute
* is set.
*
* @return void
*
* @link https://www.ietf.org/rfc/rfc2109.txt
* @link https://php.net/manual/en/function.setcookie.php
*
* @since 1.0
*
* @note As of 1.4.0, the (name, value, expire, path, domain, secure, httpOnly) signature is deprecated and will not be supported
* when support for PHP 7.2 and earlier is dropped
*/
public function set($name, $value, $options = array())
{
// BC layer to convert old method parameters.
if (is_array($options) === false)
{
$argList = func_get_args();
$options = array(
'expires' => isset($argList[2]) === true ? $argList[2] : 0,
'path' => isset($argList[3]) === true ? $argList[3] : '',
'domain' => isset($argList[4]) === true ? $argList[4] : '',
'secure' => isset($argList[5]) === true ? $argList[5] : false,
'httponly' => isset($argList[6]) === true ? $argList[6] : false,
);
}
// Set the cookie
if (version_compare(PHP_VERSION, '7.3', '>='))
{
setcookie($name, $value, $options);
}
else
{
// Using the setcookie function before php 7.3, make sure we have default values.
if (array_key_exists('expires', $options) === false)
{
$options['expires'] = 0;
}
if (array_key_exists('path', $options) === false)
{
$options['path'] = '';
}
if (array_key_exists('domain', $options) === false)
{
$options['domain'] = '';
}
if (array_key_exists('secure', $options) === false)
{
$options['secure'] = false;
}
if (array_key_exists('httponly', $options) === false)
{
$options['httponly'] = false;
}
setcookie($name, $value, $options['expires'], $options['path'], $options['domain'], $options['secure'], $options['httponly']);
}
$this->data[$name] = $value;
}
}
PK x'#]M:��
�
Files.phpnu &1i� <?php
/**
* Part of the Joomla Framework Input Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Input;
use Joomla\Filter;
/**
* Joomla! Input Files Class
*
* @since 1.0
*/
class Files extends Input
{
/**
* The pivoted data from a $_FILES or compatible array.
*
* @var array
* @since 1.0
*/
protected $decodedData = array();
/**
* The class constructor.
*
* @param array $source The source argument is ignored. $_FILES is always used.
* @param array $options An optional array of configuration options:
* filter : a custom JFilterInput object.
*
* @since 1.0
*/
public function __construct($source = null, array $options = array())
{
if (isset($options['filter']))
{
$this->filter = $options['filter'];
}
else
{
$this->filter = new Filter\InputFilter;
}
// Set the data source.
$this->data = & $_FILES;
// Set the options for the class.
$this->options = $options;
}
/**
* Gets a value from the input data.
*
* @param string $name The name of the input property (usually the name of the files INPUT tag) to get.
* @param mixed $default The default value to return if the named property does not exist.
* @param string $filter The filter to apply to the value.
*
* @return mixed The filtered input value.
*
* @see \Joomla\Filter\InputFilter::clean()
* @since 1.0
*/
public function get($name, $default = null, $filter = 'cmd')
{
if (isset($this->data[$name]))
{
$results = $this->decodeData(
array(
$this->data[$name]['name'],
$this->data[$name]['type'],
$this->data[$name]['tmp_name'],
$this->data[$name]['error'],
$this->data[$name]['size'],
)
);
return $results;
}
return $default;
}
/**
* Method to decode a data array.
*
* @param array $data The data array to decode.
*
* @return array
*
* @since 1.0
*/
protected function decodeData(array $data)
{
$result = array();
if (\is_array($data[0]))
{
foreach ($data[0] as $k => $v)
{
$result[$k] = $this->decodeData(array($data[0][$k], $data[1][$k], $data[2][$k], $data[3][$k], $data[4][$k]));
}
return $result;
}
return array('name' => $data[0], 'type' => $data[1], 'tmp_name' => $data[2], 'error' => $data[3], 'size' => $data[4]);
}
/**
* Sets a value.
*
* @param string $name The name of the input property to set.
* @param mixed $value The value to assign to the input property.
*
* @return void
*
* @since 1.0
*/
public function set($name, $value)
{
// Restricts the usage of parent's set method.
}
}
PK �+#]�����
�
AbstractEvent.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
use ArrayAccess;
use Countable;
use Serializable;
/**
* Implementation of EventInterface.
*
* @since 1.0
*/
abstract class AbstractEvent implements EventInterface, ArrayAccess, Serializable, Countable
{
/**
* The event name.
*
* @var string
*
* @since 1.0
*/
protected $name;
/**
* The event arguments.
*
* @var array
*
* @since 1.0
*/
protected $arguments;
/**
* A flag to see if the event propagation is stopped.
*
* @var boolean
*
* @since 1.0
*/
protected $stopped = false;
/**
* Constructor.
*
* @param string $name The event name.
* @param array $arguments The event arguments.
*
* @since 1.0
*/
public function __construct($name, array $arguments = array())
{
$this->name = $name;
$this->arguments = $arguments;
}
/**
* Get the event name.
*
* @return string The event name.
*
* @since 1.0
*/
public function getName()
{
return $this->name;
}
/**
* Get an event argument value.
*
* @param string $name The argument name.
* @param mixed $default The default value if not found.
*
* @return mixed The argument value or the default value.
*
* @since 1.0
*/
public function getArgument($name, $default = null)
{
if (isset($this->arguments[$name]))
{
return $this->arguments[$name];
}
return $default;
}
/**
* Tell if the given event argument exists.
*
* @param string $name The argument name.
*
* @return boolean True if it exists, false otherwise.
*
* @since 1.0
*/
public function hasArgument($name)
{
return isset($this->arguments[$name]);
}
/**
* Get all event arguments.
*
* @return array An associative array of argument names as keys
* and their values as values.
*
* @since 1.0
*/
public function getArguments()
{
return $this->arguments;
}
/**
* Tell if the event propagation is stopped.
*
* @return boolean True if stopped, false otherwise.
*
* @since 1.0
*/
public function isStopped()
{
return $this->stopped === true;
}
/**
* Count the number of arguments.
*
* @return integer The number of arguments.
*
* @since 1.0
*/
public function count()
{
return \count($this->arguments);
}
/**
* Serialize the event.
*
* @return string The serialized event.
*
* @since 1.0
*/
public function serialize()
{
return serialize(array($this->name, $this->arguments, $this->stopped));
}
/**
* Unserialize the event.
*
* @param string $serialized The serialized event.
*
* @return void
*
* @since 1.0
*/
public function unserialize($serialized)
{
list($this->name, $this->arguments, $this->stopped) = unserialize($serialized);
}
/**
* Tell if the given event argument exists.
*
* @param string $name The argument name.
*
* @return boolean True if it exists, false otherwise.
*
* @since 1.0
*/
public function offsetExists($name)
{
return $this->hasArgument($name);
}
/**
* Get an event argument value.
*
* @param string $name The argument name.
*
* @return mixed The argument value or null if not existing.
*
* @since 1.0
*/
public function offsetGet($name)
{
return $this->getArgument($name);
}
}
PK �+#]K�a�[ [ Priority.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
/**
* An enumeration of priorities for event listeners,
* that you are encouraged to use when adding them in the Dispatcher.
*
* @since 1.0
*/
final class Priority
{
const MIN = -3;
const LOW = -2;
const BELOW_NORMAL = -1;
const NORMAL = 0;
const ABOVE_NORMAL = 1;
const HIGH = 2;
const MAX = 3;
}
PK �+#]$���� � DispatcherAwareInterface.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
/**
* Interface to be implemented by classes depending on a dispatcher.
*
* @since 1.0
*/
interface DispatcherAwareInterface
{
/**
* Set the dispatcher to use.
*
* @param DispatcherInterface $dispatcher The dispatcher to use.
*
* @return DispatcherAwareInterface This method is chainable.
*
* @since 1.0
*/
public function setDispatcher(DispatcherInterface $dispatcher);
}
PK �+#]�&�� EventImmutable.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
use BadMethodCallException;
/**
* Implementation of an immutable Event.
* An immutable event cannot be modified after instanciation :
*
* - its propagation cannot be stopped
* - its arguments cannot be modified
*
* You may want to use this event when you want to ensure that
* the listeners won't manipulate it.
*
* @since 1.0
*/
final class EventImmutable extends AbstractEvent
{
/**
* A flag to see if the constructor has been
* already called.
*
* @var boolean
*/
private $constructed = false;
/**
* Constructor.
*
* @param string $name The event name.
* @param array $arguments The event arguments.
*
* @throws BadMethodCallException
*
* @since 1.0
*/
public function __construct($name, array $arguments = array())
{
if ($this->constructed)
{
throw new BadMethodCallException(
sprintf('Cannot reconstruct the EventImmutable %s.', $this->name)
);
}
$this->constructed = true;
parent::__construct($name, $arguments);
}
/**
* Set the value of an event argument.
*
* @param string $name The argument name.
* @param mixed $value The argument value.
*
* @return void
*
* @throws BadMethodCallException
*
* @since 1.0
*/
public function offsetSet($name, $value)
{
throw new BadMethodCallException(
sprintf(
'Cannot set the argument %s of the immutable event %s.',
$name,
$this->name
)
);
}
/**
* Remove an event argument.
*
* @param string $name The argument name.
*
* @return void
*
* @throws BadMethodCallException
*
* @since 1.0
*/
public function offsetUnset($name)
{
throw new BadMethodCallException(
sprintf(
'Cannot remove the argument %s of the immutable event %s.',
$name,
$this->name
)
);
}
}
PK �+#]��V V DispatcherInterface.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
/**
* Interface for event dispatchers.
*
* @since 1.0
*/
interface DispatcherInterface
{
/**
* Trigger an event.
*
* @param EventInterface|string $event The event object or name.
*
* @return EventInterface The event after being passed through all listeners.
*
* @since 1.0
*/
public function triggerEvent($event);
}
PK �+#] C�a a DispatcherAwareTrait.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
/**
* Defines the trait for a Dispatcher Aware Class.
*
* @since 1.2.0
*/
trait DispatcherAwareTrait
{
/**
* Event Dispatcher
*
* @var DispatcherInterface
* @since 1.2.0
*/
private $dispatcher;
/**
* Get the event dispatcher.
*
* @return DispatcherInterface
*
* @since 1.2.0
* @throws \UnexpectedValueException May be thrown if the dispatcher has not been set.
*/
public function getDispatcher()
{
if ($this->dispatcher)
{
return $this->dispatcher;
}
throw new \UnexpectedValueException('Dispatcher not set in ' . __CLASS__);
}
/**
* Set the dispatcher to use.
*
* @param DispatcherInterface $dispatcher The dispatcher to use.
*
* @return $this
*
* @since 1.2.0
*/
public function setDispatcher(DispatcherInterface $dispatcher)
{
$this->dispatcher = $dispatcher;
return $this;
}
}
PK �+#]�h�Hy y DelegatingDispatcher.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
/**
* A dispatcher delegating its methods to an other dispatcher.
*
* @since 1.0
* @deprecated 2.0 Create your own delegating (decorating) dispatcher as needed.
*/
final class DelegatingDispatcher implements DispatcherInterface
{
/**
* The delegated dispatcher.
*
* @var DispatcherInterface
* @since 1.0
*/
private $dispatcher;
/**
* Constructor.
*
* @param DispatcherInterface $dispatcher The delegated dispatcher.
*
* @since 1.0
*/
public function __construct(DispatcherInterface $dispatcher)
{
$this->dispatcher = $dispatcher;
}
/**
* Trigger an event.
*
* @param EventInterface|string $event The event object or name.
*
* @return EventInterface The event after being passed through all listeners.
*
* @since 1.0
*/
public function triggerEvent($event)
{
return $this->dispatcher->triggerEvent($event);
}
}
PK �+#] �H�v v ListenersPriorityQueue.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
use Countable;
use IteratorAggregate;
use SplObjectStorage;
use SplPriorityQueue;
/**
* A class containing an inner listeners priority queue that can be iterated multiple times.
* One instance of ListenersPriorityQueue is used per Event in the Dispatcher.
*
* @since 1.0
*/
class ListenersPriorityQueue implements IteratorAggregate, Countable
{
/**
* The inner priority queue.
*
* @var SplPriorityQueue
*
* @since 1.0
*/
protected $queue;
/**
* A copy of the listeners contained in the queue
* that is used when detaching them to
* recreate the queue or to see if the queue contains
* a given listener.
*
* @var SplObjectStorage
*
* @since 1.0
*/
protected $storage;
/**
* A decreasing counter used to compute
* the internal priority as an array because
* SplPriorityQueue dequeues elements with the same priority.
*
* @var integer
*
* @since 1.0
*/
private $counter = PHP_INT_MAX;
/**
* Constructor.
*
* @since 1.0
*/
public function __construct()
{
$this->queue = new SplPriorityQueue;
$this->storage = new SplObjectStorage;
}
/**
* Add a listener with the given priority only if not already present.
*
* @param \Closure|object $listener The listener.
* @param integer $priority The listener priority.
*
* @return ListenersPriorityQueue This method is chainable.
*
* @since 1.0
*/
public function add($listener, $priority)
{
if (!$this->storage->contains($listener))
{
// Compute the internal priority as an array.
$priority = array($priority, $this->counter--);
$this->storage->attach($listener, $priority);
$this->queue->insert($listener, $priority);
}
return $this;
}
/**
* Remove a listener from the queue.
*
* @param \Closure|object $listener The listener.
*
* @return ListenersPriorityQueue This method is chainable.
*
* @since 1.0
*/
public function remove($listener)
{
if ($this->storage->contains($listener))
{
$this->storage->detach($listener);
$this->storage->rewind();
$this->queue = new SplPriorityQueue;
foreach ($this->storage as $listener)
{
$priority = $this->storage->getInfo();
$this->queue->insert($listener, $priority);
}
}
return $this;
}
/**
* Tell if the listener exists in the queue.
*
* @param \Closure|object $listener The listener.
*
* @return boolean True if it exists, false otherwise.
*
* @since 1.0
*/
public function has($listener)
{
return $this->storage->contains($listener);
}
/**
* Get the priority of the given listener.
*
* @param \Closure|object $listener The listener.
* @param mixed $default The default value to return if the listener doesn't exist.
*
* @return mixed The listener priority if it exists, null otherwise.
*
* @since 1.0
*/
public function getPriority($listener, $default = null)
{
if ($this->storage->contains($listener))
{
return $this->storage[$listener][0];
}
return $default;
}
/**
* Get all listeners contained in this queue, sorted according to their priority.
*
* @return object[] An array of listeners.
*
* @since 1.0
*/
public function getAll()
{
$listeners = array();
// Get a clone of the queue.
$queue = $this->getIterator();
foreach ($queue as $listener)
{
$listeners[] = $listener;
}
return $listeners;
}
/**
* Get the inner queue with its cursor on top of the heap.
*
* @return SplPriorityQueue The inner queue.
*
* @since 1.0
*/
public function getIterator()
{
// SplPriorityQueue queue is a heap.
$queue = clone $this->queue;
if (!$queue->isEmpty())
{
$queue->top();
}
return $queue;
}
/**
* Count the number of listeners in the queue.
*
* @return integer The number of listeners in the queue.
*
* @since 1.0
*/
public function count()
{
return \count($this->queue);
}
}
PK �+#]l�Y�
Event.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
use InvalidArgumentException;
/**
* Default Event class.
*
* @since 1.0
*/
class Event extends AbstractEvent
{
/**
* Add an event argument, only if it is not existing.
*
* @param string $name The argument name.
* @param mixed $value The argument value.
*
* @return Event This method is chainable.
*
* @since 1.0
*/
public function addArgument($name, $value)
{
if (!isset($this->arguments[$name]))
{
$this->arguments[$name] = $value;
}
return $this;
}
/**
* Set the value of an event argument.
* If the argument already exists, it will be overridden.
*
* @param string $name The argument name.
* @param mixed $value The argument value.
*
* @return Event This method is chainable.
*
* @since 1.0
*/
public function setArgument($name, $value)
{
$this->arguments[$name] = $value;
return $this;
}
/**
* Remove an event argument.
*
* @param string $name The argument name.
*
* @return mixed The old argument value or null if it is not existing.
*
* @since 1.0
*/
public function removeArgument($name)
{
$return = null;
if (isset($this->arguments[$name]))
{
$return = $this->arguments[$name];
unset($this->arguments[$name]);
}
return $return;
}
/**
* Clear all event arguments.
*
* @return array The old arguments.
*
* @since 1.0
*/
public function clearArguments()
{
$arguments = $this->arguments;
$this->arguments = array();
return $arguments;
}
/**
* Stop the event propagation.
*
* @return void
*
* @since 1.0
*/
public function stop()
{
$this->stopped = true;
}
/**
* Set the value of an event argument.
*
* @param string $name The argument name.
* @param mixed $value The argument value.
*
* @return void
*
* @throws InvalidArgumentException If the argument name is null.
*
* @since 1.0
*/
public function offsetSet($name, $value)
{
if ($name === null)
{
throw new InvalidArgumentException('The argument name cannot be null.');
}
$this->setArgument($name, $value);
}
/**
* Remove an event argument.
*
* @param string $name The argument name.
*
* @return void
*
* @since 1.0
*/
public function offsetUnset($name)
{
$this->removeArgument($name);
}
}
PK �+#]�C_�� � EventInterface.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
/**
* Interface for events.
* An event has a name and its propagation can be stopped (if the implementation supports it).
*
* @since 1.0
*/
interface EventInterface
{
/**
* Get the event name.
*
* @return string The event name.
*
* @since 1.0
*/
public function getName();
/**
* Tell if the event propagation is stopped.
*
* @return boolean True if stopped, false otherwise.
*
* @since 1.0
*/
public function isStopped();
}
PK �+#]��s�U) U) Dispatcher.phpnu &1i� <?php
/**
* Part of the Joomla Framework Event Package
*
* @copyright Copyright (C) 2005 - 2019 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Event;
use Closure;
use InvalidArgumentException;
/**
* Implementation of a DispatcherInterface supporting
* prioritized listeners.
*
* @since 1.0
*/
class Dispatcher implements DispatcherInterface
{
/**
* An array of registered events indexed by
* the event names.
*
* @var EventInterface[]
*
* @since 1.0
*/
protected $events = array();
/**
* A regular expression that will filter listener method names.
*
* @var string
* @since 1.0
* @deprecated 1.1.0
*/
protected $listenerFilter;
/**
* An array of ListenersPriorityQueue indexed
* by the event names.
*
* @var ListenersPriorityQueue[]
*
* @since 1.0
*/
protected $listeners = array();
/**
* Set an event to the dispatcher.
* It will replace any event with the same name.
*
* @param EventInterface $event The event.
*
* @return Dispatcher This method is chainable.
*
* @since 1.0
*/
public function setEvent(EventInterface $event)
{
$this->events[$event->getName()] = $event;
return $this;
}
/**
* Sets a regular expression to filter the class methods when adding a listener.
*
* @param string $regex A regular expression (for example '^on' will only register methods starting with "on").
*
* @return Dispatcher This method is chainable.
*
* @since 1.0
* @deprecated 1.1.0 Incorporate a method in your listener object such as `getEvents` to feed into the `setListener` method.
*/
public function setListenerFilter($regex)
{
$this->listenerFilter = $regex;
return $this;
}
/**
* Add an event to this dispatcher, only if it is not existing.
*
* @param EventInterface $event The event.
*
* @return Dispatcher This method is chainable.
*
* @since 1.0
*/
public function addEvent(EventInterface $event)
{
if (!isset($this->events[$event->getName()]))
{
$this->events[$event->getName()] = $event;
}
return $this;
}
/**
* Tell if the given event has been added to this dispatcher.
*
* @param EventInterface|string $event The event object or name.
*
* @return boolean True if the listener has the given event, false otherwise.
*
* @since 1.0
*/
public function hasEvent($event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
return isset($this->events[$event]);
}
/**
* Get the event object identified by the given name.
*
* @param string $name The event name.
* @param mixed $default The default value if the event was not registered.
*
* @return EventInterface|mixed The event of the default value.
*
* @since 1.0
*/
public function getEvent($name, $default = null)
{
if (isset($this->events[$name]))
{
return $this->events[$name];
}
return $default;
}
/**
* Remove an event from this dispatcher.
* The registered listeners will remain.
*
* @param EventInterface|string $event The event object or name.
*
* @return Dispatcher This method is chainable.
*
* @since 1.0
*/
public function removeEvent($event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
if (isset($this->events[$event]))
{
unset($this->events[$event]);
}
return $this;
}
/**
* Get the registered events.
*
* @return EventInterface[] The registered event.
*
* @since 1.0
*/
public function getEvents()
{
return $this->events;
}
/**
* Clear all events.
*
* @return EventInterface[] The old events.
*
* @since 1.0
*/
public function clearEvents()
{
$events = $this->events;
$this->events = array();
return $events;
}
/**
* Count the number of registered event.
*
* @return integer The numer of registered events.
*
* @since 1.0
*/
public function countEvents()
{
return \count($this->events);
}
/**
* Add a listener to this dispatcher, only if not already registered to these events.
* If no events are specified, it will be registered to all events matching it's methods name.
* In the case of a closure, you must specify at least one event name.
*
* @param object|Closure $listener The listener
* @param array $events An associative array of event names as keys
* and the corresponding listener priority as values.
*
* @return Dispatcher This method is chainable.
*
* @throws InvalidArgumentException
*
* @since 1.0
*/
public function addListener($listener, array $events = array())
{
if (!\is_object($listener))
{
throw new InvalidArgumentException('The given listener is not an object.');
}
// We deal with a closure.
if ($listener instanceof Closure)
{
if (empty($events))
{
throw new InvalidArgumentException('No event name(s) and priority specified for the Closure listener.');
}
foreach ($events as $name => $priority)
{
if (!isset($this->listeners[$name]))
{
$this->listeners[$name] = new ListenersPriorityQueue;
}
$this->listeners[$name]->add($listener, $priority);
}
return $this;
}
// We deal with a "normal" object.
$methods = get_class_methods($listener);
if (!empty($events))
{
$methods = array_intersect($methods, array_keys($events));
}
// @deprecated
$regex = $this->listenerFilter ?: '.*';
foreach ($methods as $event)
{
// @deprecated - this outer `if` is deprecated.
if (preg_match("#$regex#", $event))
{
// Retain this inner code after removal of the outer `if`.
if (!isset($this->listeners[$event]))
{
$this->listeners[$event] = new ListenersPriorityQueue;
}
$priority = isset($events[$event]) ? $events[$event] : Priority::NORMAL;
$this->listeners[$event]->add($listener, $priority);
}
}
return $this;
}
/**
* Get the priority of the given listener for the given event.
*
* @param object|Closure $listener The listener.
* @param EventInterface|string $event The event object or name.
*
* @return mixed The listener priority or null if the listener doesn't exist.
*
* @since 1.0
*/
public function getListenerPriority($listener, $event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
if (isset($this->listeners[$event]))
{
return $this->listeners[$event]->getPriority($listener);
}
}
/**
* Get the listeners registered to the given event.
*
* @param EventInterface|string $event The event object or name.
*
* @return object[] An array of registered listeners sorted according to their priorities.
*
* @since 1.0
*/
public function getListeners($event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
if (isset($this->listeners[$event]))
{
return $this->listeners[$event]->getAll();
}
return array();
}
/**
* Tell if the given listener has been added.
* If an event is specified, it will tell if the listener is registered for that event.
*
* @param object|Closure $listener The listener.
* @param EventInterface|string $event The event object or name.
*
* @return boolean True if the listener is registered, false otherwise.
*
* @since 1.0
*/
public function hasListener($listener, $event = null)
{
if ($event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
if (isset($this->listeners[$event]))
{
return $this->listeners[$event]->has($listener);
}
}
else
{
foreach ($this->listeners as $queue)
{
if ($queue->has($listener))
{
return true;
}
}
}
return false;
}
/**
* Remove the given listener from this dispatcher.
* If no event is specified, it will be removed from all events it is listening to.
*
* @param object|Closure $listener The listener to remove.
* @param EventInterface|string $event The event object or name.
*
* @return Dispatcher This method is chainable.
*
* @since 1.0
*/
public function removeListener($listener, $event = null)
{
if ($event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
if (isset($this->listeners[$event]))
{
$this->listeners[$event]->remove($listener);
}
}
else
{
foreach ($this->listeners as $queue)
{
$queue->remove($listener);
}
}
return $this;
}
/**
* Clear the listeners in this dispatcher.
* If an event is specified, the listeners will be cleared only for that event.
*
* @param EventInterface|string $event The event object or name.
*
* @return Dispatcher This method is chainable.
*
* @since 1.0
*/
public function clearListeners($event = null)
{
if ($event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
if (isset($this->listeners[$event]))
{
unset($this->listeners[$event]);
}
}
else
{
$this->listeners = array();
}
return $this;
}
/**
* Count the number of registered listeners for the given event.
*
* @param EventInterface|string $event The event object or name.
*
* @return integer The number of registered listeners for the given event.
*
* @since 1.0
*/
public function countListeners($event)
{
if ($event instanceof EventInterface)
{
$event = $event->getName();
}
return isset($this->listeners[$event]) ? \count($this->listeners[$event]) : 0;
}
/**
* Trigger an event.
*
* @param EventInterface|string $event The event object or name.
*
* @return EventInterface The event after being passed through all listeners.
*
* @since 1.0
*/
public function triggerEvent($event)
{
if (!($event instanceof EventInterface))
{
if (isset($this->events[$event]))
{
$event = $this->events[$event];
}
else
{
$event = new Event($event);
}
}
if (isset($this->listeners[$event->getName()]))
{
foreach ($this->listeners[$event->getName()] as $listener)
{
if ($event->isStopped())
{
return $event;
}
if ($listener instanceof Closure)
{
\call_user_func($listener, $event);
}
else
{
\call_user_func(array($listener, $event->getName()), $event);
}
}
}
return $event;
}
}
PK +#]P���> �> LdapClient.phpnu &1i� PK D#]V�� � ? Helper/UUID4.phpnu &1i� PK D#] �u u 8F Extension/AkeebaBackup.phpnu &1i� PK n #]*��9 �9 �` DataSet.phpnu &1i� PK n #]
���! ! .� DumpableInterface.phpnu &1i� PK n #]��`g" g" �� DataObject.phpnu &1i� PK � #]��� � 9� ContainerAwareTrait.phpnu &1i� PK � #]�B B � ContainerAwareInterface.phpnu &1i� PK � #]��$� � " �� Exception/KeyNotFoundException.phpnu &1i� PK � #]���� � # �� Exception/ProtectedKeyException.phpnu &1i� PK � #]y�q� � + � Exception/DependencyResolutionException.phpnu &1i� PK � #]�td�? ? a� ServiceProviderInterface.phpnu &1i� PK � #]֬gsp5 p5
�� Container.phpnu &1i� PK � #],����
�
� ImageFilter.phpnu &1i� PK � #]*W�� � Filter/Negate.phpnu &1i� PK � #]�
� � Filter/Emboss.phpnu &1i� PK � #]�LE A Filter/Sketchy.phpnu &1i� PK � #] �f�� � � Filter/Brightness.phpnu &1i� PK � #]e�E $ $ d# Filter/Edgedetect.phpnu &1i� PK � #]�SUp�
�
�& Filter/Backgroundfill.phpnu &1i� PK � #]�� �4 Filter/Grayscale.phpnu &1i� PK � #]җ��p p 8 Filter/Smooth.phpnu &1i� PK � #]�=c�u u �< Filter/Contrast.phpnu &1i� PK � #]�^M(| (| �A Image.phpnu &1i� PK x'#]�{�% �% � Input.phpnu &1i� PK x'#]2Fh� � �� Cli.phpnu &1i� PK x'#]h� � � Json.phpnu &1i� PK x'#]/g���
�
-� Cookie.phpnu &1i� PK x'#]M:��
�
�
Files.phpnu &1i� PK �+#]�����
�
& AbstractEvent.phpnu &1i� PK �+#]K�a�[ [ P$ Priority.phpnu &1i� PK �+#]$���� � �& DispatcherAwareInterface.phpnu &1i� PK �+#]�&�� �) EventImmutable.phpnu &1i� PK �+#]��V V
2 DispatcherInterface.phpnu &1i� PK �+#] C�a a �4 DispatcherAwareTrait.phpnu &1i� PK �+#]�h�Hy y S9 DelegatingDispatcher.phpnu &1i� PK �+#] �H�v v > ListenersPriorityQueue.phpnu &1i� PK �+#]l�Y�
�N Event.phpnu &1i� PK �+#]�C_�� � $Y EventInterface.phpnu &1i� PK �+#]��s�U) U) 4\ Dispatcher.phpnu &1i� PK ( ( � Dž