HttpRequest - Code Metrics - Inspection of "Merge pull request #558 from geekwright/xmfuuid" - XOOPS/XoopsCore - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( d0941c...c232a4 )

by Michael
created 2017-10-05 02:39 UTC
HttpRequest D

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	619
Duplicated Lines	6.79 %
Coupling/Cohesion

Components	2
Dependencies	2
Test Coverage

Coverage
47.72%
Importance

Changes
Metric	Value
dl	42
loc	619
ccs	94
cts	197
cp	0.4772
rs	4.7957
c	0
b	0
f	0
wmc	91
lcom	2
cbo	2
21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	3
B	getHeader()	0	21	5
A	getScheme()	0	4	2
A	getHost()	0	4	2
B	getUri()	0	12	5
A	getReferer()	0	4	2
A	getScriptName()	0	6	3
A	getDomain()	0	6	2
A	getInstance()	0	7	2
A	getSubdomains()	0	13	4
C	getClientIp()	0	33	7
A	getUrl()	0	9	2
C	getEnv()	0	65	21
B	getFiles()	0	25	5
B	is()	0	16	6
A	detectByEnv()	0	12	4
A	detectByParam()	0	6	2
A	addDetector()	0	8	3
A	clientAcceptsType()	0	15	3
A	getAcceptMediaTypes()	21	21	4
A	getAcceptedLanguages()	21	21	4
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like HttpRequest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use HttpRequest, and based on these observations, apply Extract Interface, too.
<?php
/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */

namespace Xoops\Core;

/**
 * WARNING: THIS IS A PLACEHOLDER ONLY. IMPLEMENTATION AND DETAILS WILL CHANGE.
 *
 * This provides some of the functionality that was in the Xoops_Request classes.
 * The majority of use for the class was the 'asXyz()' methods, and all such uses
 * should move to Xmf\Request::getXyz() methods.
 *
 * These are methods which reveal some aspects of the HTTP request environment.
 * This will eventually be reworked to depend on a full HTTP message library
 * (anticipating an official PSR-7 implementation.)
 *
 * For now, this is a reduced version of a Cake derivative.
 *
 */

/**
 * HttpRequest
 *
 * @category  Xoops\Core\HttpRequest
 * @package   Xoops\Core
 * @author    trabis <[email protected]>
 * @author    Kazumi Ono <[email protected]>
 * @author    Richard Griffith <[email protected]>
 * @copyright 2011-2015 XOOPS Project (http://xoops.org)
 * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 * @link      http://xoops.org
 */
class HttpRequest

{
    /**
     * @var array
     */
    protected $params;

    /**
     * @var HttpRequest The reference to *Singleton* instance of this class
     */
    private static $instance;

    /**
     * The built in detectors used with `is()` can be modified with `addDetector()`.
     * There are several ways to specify a detector, see HttpRequest::addDetector() for the
     * various formats and ways to define detectors.
     *
     * @var array
     */
    protected $detectors = array(
        'get'       => array('env' => 'REQUEST_METHOD', 'value' => 'GET'),
        'post'      => array('env' => 'REQUEST_METHOD', 'value' => 'POST'),
        'put'       => array('env' => 'REQUEST_METHOD', 'value' => 'PUT'),
        'delete'    => array('env' => 'REQUEST_METHOD', 'value' => 'DELETE'),
        'head'      => array('env' => 'REQUEST_METHOD', 'value' => 'HEAD'),
        'options'   => array('env' => 'REQUEST_METHOD', 'value' => 'OPTIONS'),
        'safemethod'=> array('env' => 'REQUEST_METHOD', 'options' => array('GET', 'HEAD')),
        'ssl'       => array('env' => 'HTTPS', 'value' => 1),
        'ajax'      => array('env' => 'HTTP_X_REQUESTED_WITH', 'value' => 'XMLHttpRequest'),
        'flash'     => array('env' => 'HTTP_USER_AGENT', 'pattern' => '/^(Shockwave|Adobe) Flash/'),
        'mobile'    => array(
            'env'     => 'HTTP_USER_AGENT',
            'options' => array(
                'Android',
                'AvantGo',
                'BlackBerry',
                'DoCoMo',
                'Fennec',
                'iPod',
                'iPhone',
                'iPad',
                'J2ME',
                'MIDP',
                'NetFront',
                'Nokia',
                'Opera Mini',
                'Opera Mobi',
                'PalmOS',
                'PalmSource',
                'portalmmm',
                'Plucker',
                'ReqwirelessWeb',
                'SonyEricsson',
                'Symbian',
                'UP\\.Browser',
                'webOS',
                'Windows CE',
                'Windows Phone OS',
                'Xiino'
            )
        ),
        'robot'     => array(
            'env'     => 'HTTP_USER_AGENT',
            'options' => array(
                /* The most common ones. */
                'Googlebot',
                'msnbot',
                'Slurp',
                'Yahoo',
                /* The rest alphabetically. */
                'Arachnoidea',
                'ArchitextSpider',
                'Ask Jeeves',
                'B-l-i-t-z-Bot',
                'Baiduspider',
                'BecomeBot',
                'cfetch',
                'ConveraCrawler',
                'ExtractorPro',
                'FAST-WebCrawler',
                'FDSE robot',
                'fido',
                'geckobot',
                'Gigabot',
                'Girafabot',
                'grub-client',
                'Gulliver',
                'HTTrack',
                'ia_archiver',
                'InfoSeek',
                'kinjabot',
                'KIT-Fireball',
                'larbin',
                'LEIA',
                'lmspider',
                'Lycos_Spider',
                'Mediapartners-Google',
                'MuscatFerret',
                'NaverBot',
                'OmniExplorer_Bot',
                'polybot',
                'Pompos',
                'Scooter',
                'Teoma',
                'TheSuBot',
                'TurnitinBot',
                'Ultraseek',
                'ViolaBot',
                'webbandit',
                'www\\.almaden\\.ibm\\.com\\/cs\\/crawler',
                'ZyBorg',
            )
        ),
    );

    /**
     * __construct
     */
    private function __construct()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        switch (strtolower($this->getEnv('REQUEST_METHOD'))) {
            case 'get':
                $params = $_GET;
                break;
            case 'put':
                parse_str(file_get_contents('php://input'), $put);
                $params = array_merge($_GET, $put);
                break;
            default:
                $params = array_merge($_GET, $_POST);
        }
        $this->params = $params;
    }

    /**
     * get singleton instance, establish the request data on first access
     *
     * @return HttpRequest
     */
    public static function getInstance()
    {
        if (null === static::$instance) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            static::$instance = new static();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        }
        return static::$instance;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    /**
     * get a http header for the current request
     *
     * @param null|string $name header name
     *
     * @return null|string
     */
    public function getHeader($name = null)
    {
        if ($name === null) {
            return $name;
        }

        // Try to get it from the $_SERVER array first
        if ($res = $this->getEnv('HTTP_' . strtoupper(str_replace('-', '_', $name)))) {
            return $res;
        }

        // This seems to be the only way to get the Authorization header on
        // Apache
        if (function_exists('apache_request_headers')) {
            $headers = apache_request_headers();
            if (!empty($headers[$name])) {
                return $headers[$name];
            }
        }
        return null;
    }

    /**
     * get the scheme of current request
     *
     * @return string
     */
    public function getScheme()
    {
        return $this->getEnv('HTTPS') ? 'https' : 'http';
    }

    /**
     * get the host from the current request
     *
     * @return string
     */
    public function getHost()
    {
        return $this->getEnv('HTTP_HOST') ? (string) $this->getEnv('HTTP_HOST') : 'localhost';
    }

    /**
     * get the URI of the current request
     *
     * @return null|string
     */
    public static function getUri()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (empty($_SERVER['PHP_SELF']) || empty($_SERVER['REQUEST_URI'])) {
            // IIS
            $_SERVER['REQUEST_URI'] = $_SERVER['SCRIPT_NAME'];
            if (!empty($_SERVER['QUERY_STRING'])) {
                $_SERVER['REQUEST_URI'] .= '?' . $_SERVER['QUERY_STRING'];
            }
            return $_SERVER['REQUEST_URI'];
        }
        return isset($_SERVER['ORIG_REQUEST_URI']) ? $_SERVER['ORIG_REQUEST_URI'] : $_SERVER['REQUEST_URI'];
    }

    /**
     * get the referer of the current request
     *
     * @return string
     */
    public function getReferer()
    {
        return $this->getEnv('HTTP_REFERER') ? $this->getEnv('HTTP_REFERER') : '';
    }

    /**
     * get the current script name associated with the request
     *
     * @return string
     */
    public function getScriptName()
    {
        return $this->getEnv('SCRIPT_NAME')
            ? $this->getEnv('SCRIPT_NAME')
            : ($this->getEnv('ORIG_SCRIPT_NAME') ? $this->getEnv('ORIG_SCRIPT_NAME') : '');
    }

    /**
     * Get the domain name and include $tldLength segments of the tld.
     *
     * @return string Domain name without subdomains
     */
    public function getDomain()
    {
        $host = $this->getHost();
        $domain =  \Xoops::getInstance()->getBaseDomain($host);
        return is_null($domain) ? $host : $domain;
    }

    /**
     * Get the subdomains for a host.
     *
     * @return string subdomain portion of host name
     */
    public function getSubdomains()
    {
        $host = $this->getHost();
        $regDom  = \Xoops::getInstance()->getBaseDomain($host);
        $fullDom = \Xoops::getInstance()->getBaseDomain($host, true);
        if (empty($regDom) || empty($fullDom)) {
            return '';
        }
        $regPattern = '/' . $regDom . '$/';
        $subdomain = preg_replace($regPattern, '', $fullDom);
        $subdomain = preg_replace('/\.$/', '', $subdomain);
        return empty($subdomain) ? '' : $subdomain;
    }

    /**
     * Get the Client IP address, optionally attempting to peek behind any proxies
     * to get a real routable address.
     *
     * @param boolean $considerProxy true to enable proxy tests
     *
     * @return string
     */
    public function getClientIp($considerProxy = false)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $default = (array_key_exists('REMOTE_ADDR', $_SERVER)) ? $_SERVER['REMOTE_ADDR'] : '0.0.0.0';

        if (!$considerProxy) {
            return $default;
        }

        $keys = array(
            'HTTP_CLIENT_IP',
            'HTTP_X_FORWARDED_FOR',
            'HTTP_X_FORWARDED',
            'HTTP_X_CLUSTER_CLIENT_IP',
            'HTTP_FORWARDED_FOR',
            'HTTP_FORWARDED',
        );
        foreach ($keys as $key) {
            if (array_key_exists($key, $_SERVER) === true) {
                foreach (explode(',', $_SERVER[$key]) as $ip) {
                    $ip = trim($ip);
                    if (false !== filter_var(
                        $ip,
                        FILTER_VALIDATE_IP,
                        FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE
                    )) {
                        return $ip;
                    }
                }
            }
        }

        return $default;
    }

    /**
     * Return current url
     *
     * @return string
     */
    public function getUrl()
    {
        $url = $this->getScheme() . "://" . $this->getHost();
        $port = $this->getEnv('SERVER_PORT');
        if (80 != $port) {
            $url .= ":{$port}";
        }
        return $url . $this->getUri();
    }

    /**
     * Gets an environment variable from available sources, and provides emulation
     * for unsupported or inconsistent environment variables (i.e. DOCUMENT_ROOT on
     * IIS, or SCRIPT_NAME in CGI mode).  Also exposes some additional custom
     * environment information.
     * Note : code modifications for XOOPS
     *
     * @param string $name    Environment variable name.
     * @param mixed  $default default value
     *
     * @return string|boolean Environment variable setting.
     * @link http://book.cakephp.org/2.0/en/core-libraries/global-constants-and-functions.html#env
     *
     * @todo this methods and Xoops::getEnv() need to be unified
     */
    public function getEnv($name, $default = null)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if ($name === 'HTTPS') {
            if (isset($_SERVER['HTTPS'])) {
                return (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off');
            }
            return (strpos($this->getEnv('SCRIPT_URI'), 'https://') === 0);
        }

        if ($name === 'SCRIPT_NAME' && !isset($_SERVER[$name])) {
            if ($this->getEnv('CGI_MODE') && isset($_ENV['SCRIPT_URL'])) {
                return $_ENV['SCRIPT_URL'];
            }
        }

        if ($name === 'REMOTE_ADDR' && !isset($_SERVER[$name])) {
            $address = $this->getEnv('HTTP_PC_REMOTE_ADDR');
            if ($address !== null) {
                return $address;
            }
        }

        $val = null;
        if (isset($_SERVER[$name])) {
            $val = $_SERVER[$name];
        } elseif (isset($_ENV[$name])) {
            $val = $_ENV[$name];
        }

        if ($val !== null) {
            return $val;
        }

        switch ($name) {
            case 'SCRIPT_FILENAME':
                $val = preg_replace('#//+#', '/', $this->getEnv('PATH_TRANSLATED'));
                return preg_replace('#\\\\+#', '\\', $val);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'DOCUMENT_ROOT':
                $name = $this->getEnv('SCRIPT_NAME');
                $filename = $this->getEnv('SCRIPT_FILENAME');
                $offset = 0;
                if (!strpos($name, '.php')) {
                    $offset = 4;
                }
                return substr($filename, 0, -(strlen($name) + $offset));
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'PHP_SELF':
                return str_replace($this->getEnv('DOCUMENT_ROOT'), '', $this->getEnv('SCRIPT_FILENAME'));
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'CGI_MODE':
                return (PHP_SAPI === 'cgi');
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
            case 'HTTP_BASE':
                $host = $this->getEnv('HTTP_HOST');
                $val = \Xoops::getInstance()->getBaseDomain($host);
                if (is_null($val)) {
                    return $default;
                } else {
                    return '.' . $val;
                }
                break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        }
        return $default;
    }

    /**
     * get files associated with the current request
     *
     * @param string $name name of file
     *
     * @return array
     */
    public static function getFiles($name)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (empty($_FILES)) {
            return array();
        }

        if (isset($_FILES[$name])) {
            return $_FILES[$name];
        }

        if (false === $pos = strpos($name, '[')) {
            return array();
        }

        $base = substr($name, 0, $pos);
        $key = str_replace(array(']', '['), array('', '"]["'), substr($name, $pos + 1, -1));
        $code = array(sprintf('if (!isset($_FILES["%s"]["name"]["%s"])) return array();', $base, $key));
        $code[] = '$file = array();';
        foreach (array('name', 'type', 'size', 'tmp_name', 'error') as $property) {
            $code[] = sprintf('$file["%1$s"] = $_FILES["%2$s"]["%1$s"]["%3$s"];', $property, $base, $key);
        }
        $code[] = 'return $file;';

        return eval(implode(PHP_EOL, $code));

    }

    /**
     * Check whether or not a Request is a certain type.  Uses the built in detection rules
     * as well as additional rules defined with HttpRequest::addDetector().  Any detector can be called
     * as `is($type)` or `is$Type()`.
     *
     * @param string $type The type of request you want to check.
     *
     * @return boolean Whether or not the request is the type you are checking.
     */
    public function is($type)
    {
        $type = strtolower($type);
        if (!isset($this->detectors[$type])) {
            return false;
        }
        $detect = $this->detectors[$type];
        if (isset($detect['env'])) {
            return $this->detectByEnv($detect);
        } elseif (isset($detect['param'])) {
            return $this->detectByParam($detect);
        } elseif (isset($detect['callback']) && is_callable($detect['callback'])) {
            return call_user_func($detect['callback'], $this);
        }
        return false;
    }

    /**
     * detectByEnv - perform detection on detectors with an 'env' component
     *
     * @param array $detect a detectors array entry to test against
     *
     * @return boolean true if detect is matched, false if not
     */
    protected function detectByEnv($detect)
    {
        if (isset($detect['value'])) {
            return (bool) $this->getEnv($detect['env']) == $detect['value'];
        } elseif (isset($detect['pattern'])) {
            return (bool) preg_match($detect['pattern'], $this->getEnv($detect['env']));
        } elseif (isset($detect['options'])) {
            $pattern = '/' . implode('|', $detect['options']) . '/i';
            return (bool) preg_match($pattern, $this->getEnv($detect['env']));
        }
        return false; // can't match a broken rule
    }

    /**
     * detectByParam - perform detection on detectors with an 'param' component.
     * To match an entry with the name in the 'param' key of the $detect rule must
     * exist in the $params property and be equal to the 'value' entry specified
     * in the $detect array.
     *
     * @param array $detect a detectors array entry to test against. Param entries are
     *                      of the form array('param' => name, 'value' => value)
     *
     * @return boolean true if detect is matched, false if not
     */
    protected function detectByParam($detect)
    {
        $name = $detect['param'];
        $value = $detect['value'];
        return isset($this->params[$name]) ? $this->params[$name] == $value : false;
    }

    /**
     * Add a new detector to the list of detectors that a request can use.
     * There are several different formats and types of detectors that can be set.
     * ### Environment value comparison
     * An environment value comparison, compares a value fetched from `env()` to a known value
     * the environment value is equality checked against the provided value.
     * e.g `addDetector('post', array('env' => 'REQUEST_METHOD', 'value' => 'POST'))`
     * ### Pattern value comparison
     * Pattern value comparison allows you to compare a value fetched from `env()` to a regular expression.
     * e.g `addDetector('iphone', array('env' => 'HTTP_USER_AGENT', 'pattern' => '/iPhone/i'));`
     * ### Option based comparison
     * Option based comparisons use a list of options to create a regular expression.  Subsequent calls
     * to add an already defined options detector will merge the options.
     * e.g `addDetector('mobile', array('env' => 'HTTP_USER_AGENT', 'options' => array('Fennec')));`
     * ### Callback detectors
     * Callback detectors allow you to provide a 'callback' type to handle the check.  The callback will
     * receive the request object as its only parameter.
     * e.g `addDetector('custom', array('callback' => array('SomeClass', 'someMethod')));`
     * ### Request parameter detectors
     * Allows for custom detectors on the request parameters.
     * e.g `addDetector('post', array('param' => 'requested', 'value' => 1)`
     *
     * @param string $name    The name of the detector.
     * @param array  $options The options for the detector definition.  See above.
     *
     * @return void
     */
    public function addDetector($name, $options)
    {
        $name = strtolower($name);
        if (isset($this->detectors[$name]) && isset($options['options'])) {
            $options = \Xoops\Utils::arrayRecursiveMerge($this->detectors[$name], $options);
        }
        $this->detectors[$name] = $options;
    }

    /**
     * Determine if a client accepts a given media type
     *
     * @param string $mediaType The content type to check for.
     *
     * @return boolean true if client accepts the media type, otherwise false
     */
    public function clientAcceptsType($mediaType)
    {
        $accepts = $this->getAcceptMediaTypes();

        $mediaType = trim($mediaType);
        if (isset($accepts[$mediaType])) {
            return true;
        }
        list($type) = explode('/', $mediaType);
        if (isset($accepts[$type.'/*'])) {
            return true;
        }

        return isset($accepts['*/*']);
    }

    /**
     * getAcceptMediaTypes returns the http-accept header as an
     * array of media types arranged by specified preference
     *
     * @return array associative array of preference (numeric weight >0 <=1.0 )
     *               keyed by media types, and sorted by preference
     */
    public function getAcceptMediaTypes()
    {
        $types = array();
        $accept = $this->getHeader('ACCEPT');

        if (!empty($accept)) {
            $entries = explode(',', $accept);
            foreach ($entries as $e) {
                $mt = explode(';q=', $e);
                if (!isset($mt[1])) {
                    $mt[1] = 1.0;
                }
                $types[trim($mt[0])] = (float) $mt[1];
            }

            // sort list based on value
            arsort($types, SORT_NUMERIC);
        }

        return($types);
    }

    /**
     * getAcceptedLanguages returns the http-accept-language header as an
     * array of language codes arranged by specified preference
     *
     * @return array associative array of preference (numeric weight >0 <=1.0 )
     *               keyed by language code, and sorted by preference
     */
    public function getAcceptedLanguages()
    {
        $languages = array();
        $accept = $this->getHeader('ACCEPT_LANGUAGE');

        if (!empty($accept)) {
            $entries = explode(',', $accept);
            foreach ($entries as $e) {
                $l = explode(';q=', $e);
                if (!isset($l[1])) {
                    $l[1] = 1.0;
                }
                $languages[trim($l[0])] = (float) $l[1];
            }

            // sort list based on value
            arsort($languages, SORT_NUMERIC);
        }

        return($languages);
    }
}

XOOPS / XoopsCore
