Browscap::getFormatter() - Code Metrics - crossjoin/Browscap - Measure and Improve Code Quality continuously with Scrutinizer

Browscap::getFormatter() A
last analyzed 2017-02-02 16:53 UTC

↳ Parent: Browscap

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	8
rs	9.4285
cc	2
eloc	4
nc	2
nop	0

<?php
declare(strict_types=1);

namespace Crossjoin\Browscap;

use Crossjoin\Browscap\Exception\ParserConfigurationException;
use Crossjoin\Browscap\Exception\ParserRuntimeException;
use Crossjoin\Browscap\Formatter\FormatterInterface;
use Crossjoin\Browscap\Formatter\PhpGetBrowser;
use Crossjoin\Browscap\Parser\ParserInterface;
use Crossjoin\Browscap\Parser\Sqlite\Parser;

/**
 * Class Browscap
 *
 * @package Crossjoin\Browscap
 * @author Christoph Ziegenberg <[email protected]>
 * @link https://github.com/crossjoin/browscap
 */
class Browscap
{
    const VERSION = '3.0.0';

    /**
     * @var ParserInterface
     */
    protected $parser;

    /**
     * @var FormatterInterface
     */
    protected $formatter;

    /**
     * Update probability percentage, so a value of 1 would check for updates in
     * 1% of the requests. A value of 0 disables automatic updates (default).
     *
     * @var int
     */
    protected $autoUpdateProbability = 0;

    /**
     * @return ParserInterface
     * @throws ParserConfigurationException
     */
    public function getParser() : ParserInterface
    {
        if ($this->parser === null) {
            $this->setParser(new Parser());
        }

        return $this->parser;
    }

    /**
     * @param ParserInterface $parser
     *
     * @return Browscap
     */
    public function setParser(ParserInterface $parser) : Browscap
    {
        $this->parser = $parser;

        return $this;
    }

    /**
     * @return FormatterInterface
     */
    public function getFormatter() : FormatterInterface
    {
        if ($this->formatter === null) {
            $this->setFormatter(new PhpGetBrowser());
        }

        return $this->formatter;
    }

    /**
     * @param FormatterInterface $formatter
     *
     * @return Browscap
     */
    public function setFormatter(FormatterInterface $formatter) : Browscap
    {
        $this->formatter = $formatter;

        return $this;
    }

    /**
     * @return int
     */
    public function getAutoUpdateProbability() : int
    {
        return $this->autoUpdateProbability;
    }

    /**
     * @param int $autoUpdateProbability
     *
     * @return Browscap
     */
    public function setAutoUpdateProbability(int $autoUpdateProbability) : Browscap
    {
        $this->autoUpdateProbability = $autoUpdateProbability;

        return $this;
    }

    /**
     * @param string|null $userAgent
     *
     * @return mixed
     * @throws ParserConfigurationException
     * @throws ParserRuntimeException
     */
    public function getBrowser(string $userAgent = null)
    {
        // Check if an automatic update is required
        $this->autoUpdate();

        // If no user agent is set, try to get it from the HTTP headers
        if ($userAgent === null) {
            $userAgent = $_SERVER['HTTP_USER_AGENT'] ?? '';
        }

        // Get rwa Browscap data and return a formatted version, using the set Formatter
        $browscapData = $this->getParser()->getReader()->getBrowser($userAgent);
        return $this->getFormatter()->format($browscapData);
    }

    /**
     * @return Browscap
     * @throws ParserConfigurationException
     * @throws ParserRuntimeException
     */
    protected function autoUpdate() : Browscap
    {
        $updateProbability = $this->getAutoUpdateProbability();
        if ($updateProbability >= random_int(1, 100) || $this->getParser()->getReader()->isUpdateRequired()) {
            $this->update();
        }

        return $this;
    }

    /**
     * Updates Browscap data. Returns a boolean indicating if an update has been done or
     * not (because not required). If the option 'forceUpdate' is used, the update is always
     * done, no matter if required or not.
     *
     * @param bool $forceUpdate
     *
     * @return bool
     * @throws ParserConfigurationException
     * @throws ParserRuntimeException
     */
    public function update(bool $forceUpdate = false) : bool
    {
        $parser = $this->getParser();

        // Check if an update is required, either because it's forced, or the source is newer
        $updateRequired = $forceUpdate;
        if ($updateRequired === false) {
            $reader = $parser->getReader();
            $source = $parser->getSource();
            $updateRequired = (
                $reader->isUpdateRequired() ||
                $reader->getType() !== $source->getType() ||
                $reader->getVersion() < $source->getVersion()
            );
        }

        // Generate ne parser data, if an update is required
        if ($updateRequired === true) {
            $parser->getWriter()->generate();

            // Re-initiate the reader and check if the update is still required,
            // if so, there's something wrong with the generation of the data.
            $reader = $parser->getReader(true);
            if ($reader->isUpdateRequired() === true) {
                throw new ParserRuntimeException(
                    'There is something wrong with the parser. The data have been re-generated without errors, ' .
                    'but the reader still requires an update of the data...'
                );
            }
        }

        return $updateRequired;
    }

    /**
     * Use the class instance as a function that exactly behaves like PHP get_browser().
     *
     * @param string $userAgent
     * @param bool $returnArray
     *
     * @return mixed
     * @throws ParserConfigurationException
     * @throws ParserRuntimeException
     */
    public function __invoke(string $userAgent, bool $returnArray = false)
    {
        $this->setFormatter(new PhpGetBrowser($returnArray));
        return $this->getBrowser($userAgent);
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Crossjoin\Browscap;
5
6			use Crossjoin\Browscap\Exception\ParserConfigurationException;
7			use Crossjoin\Browscap\Exception\ParserRuntimeException;
8			use Crossjoin\Browscap\Formatter\FormatterInterface;
9			use Crossjoin\Browscap\Formatter\PhpGetBrowser;
10			use Crossjoin\Browscap\Parser\ParserInterface;
11			use Crossjoin\Browscap\Parser\Sqlite\Parser;
12
13			/**
14			* Class Browscap
15			*
16			* @package Crossjoin\Browscap
17			* @author Christoph Ziegenberg <[email protected]>
18			* @link https://github.com/crossjoin/browscap
19			*/
20			class Browscap
21			{
22			const VERSION = '3.0.0';
23
24			/**
25			* @var ParserInterface
26			*/
27			protected $parser;
28
29			/**
30			* @var FormatterInterface
31			*/
32			protected $formatter;
33
34			/**
35			* Update probability percentage, so a value of 1 would check for updates in
36			* 1% of the requests. A value of 0 disables automatic updates (default).
37			*
38			* @var int
39			*/
40			protected $autoUpdateProbability = 0;
41
42			/**
43			* @return ParserInterface
44			* @throws ParserConfigurationException
45			*/
46			public function getParser() : ParserInterface
47			{
48			if ($this->parser === null) {
49			$this->setParser(new Parser());
50			}
51
52			return $this->parser;
53			}
54
55			/**
56			* @param ParserInterface $parser
57			*
58			* @return Browscap
59			*/
60			public function setParser(ParserInterface $parser) : Browscap
61			{
62			$this->parser = $parser;
63
64			return $this;
65			}
66
67			/**
68			* @return FormatterInterface
69			*/
70			public function getFormatter() : FormatterInterface
71			{
72			if ($this->formatter === null) {
73			$this->setFormatter(new PhpGetBrowser());
74			}
75
76			return $this->formatter;
77			}
78
79			/**
80			* @param FormatterInterface $formatter
81			*
82			* @return Browscap
83			*/
84			public function setFormatter(FormatterInterface $formatter) : Browscap
85			{
86			$this->formatter = $formatter;
87
88			return $this;
89			}
90
91			/**
92			* @return int
93			*/
94			public function getAutoUpdateProbability() : int
95			{
96			return $this->autoUpdateProbability;
97			}
98
99			/**
100			* @param int $autoUpdateProbability
101			*
102			* @return Browscap
103			*/
104			public function setAutoUpdateProbability(int $autoUpdateProbability) : Browscap
105			{
106			$this->autoUpdateProbability = $autoUpdateProbability;
107
108			return $this;
109			}
110
111			/**
112			* @param string\|null $userAgent
113			*
114			* @return mixed
115			* @throws ParserConfigurationException
116			* @throws ParserRuntimeException
117			*/
118			public function getBrowser(string $userAgent = null)
119			{
120			// Check if an automatic update is required
121			$this->autoUpdate();
122
123			// If no user agent is set, try to get it from the HTTP headers
124			if ($userAgent === null) {
125			$userAgent = $_SERVER['HTTP_USER_AGENT'] ?? '';
126			}
127
128			// Get rwa Browscap data and return a formatted version, using the set Formatter
129			$browscapData = $this->getParser()->getReader()->getBrowser($userAgent);
130			return $this->getFormatter()->format($browscapData);
131			}
132
133			/**
134			* @return Browscap
135			* @throws ParserConfigurationException
136			* @throws ParserRuntimeException
137			*/
138			protected function autoUpdate() : Browscap
139			{
140			$updateProbability = $this->getAutoUpdateProbability();
141			if ($updateProbability >= random_int(1, 100) \|\| $this->getParser()->getReader()->isUpdateRequired()) {
142			$this->update();
143			}
144
145			return $this;
146			}
147
148			/**
149			* Updates Browscap data. Returns a boolean indicating if an update has been done or
150			* not (because not required). If the option 'forceUpdate' is used, the update is always
151			* done, no matter if required or not.
152			*
153			* @param bool $forceUpdate
154			*
155			* @return bool
156			* @throws ParserConfigurationException
157			* @throws ParserRuntimeException
158			*/
159			public function update(bool $forceUpdate = false) : bool
160			{
161			$parser = $this->getParser();
162
163			// Check if an update is required, either because it's forced, or the source is newer
164			$updateRequired = $forceUpdate;
165			if ($updateRequired === false) {
166			$reader = $parser->getReader();
167			$source = $parser->getSource();
168			$updateRequired = (
169			$reader->isUpdateRequired() \|\|
170			$reader->getType() !== $source->getType() \|\|
171			$reader->getVersion() < $source->getVersion()
172			);
173			}
174
175			// Generate ne parser data, if an update is required
176			if ($updateRequired === true) {
177			$parser->getWriter()->generate();
178
179			// Re-initiate the reader and check if the update is still required,
180			// if so, there's something wrong with the generation of the data.
181			$reader = $parser->getReader(true);
182			if ($reader->isUpdateRequired() === true) {
183			throw new ParserRuntimeException(
184			'There is something wrong with the parser. The data have been re-generated without errors, ' .
185			'but the reader still requires an update of the data...'
186			);
187			}
188			}
189
190			return $updateRequired;
191			}
192
193			/**
194			* Use the class instance as a function that exactly behaves like PHP get_browser().
195			*
196			* @param string $userAgent
197			* @param bool $returnArray
198			*
199			* @return mixed
200			* @throws ParserConfigurationException
201			* @throws ParserRuntimeException
202			*/
203			public function __invoke(string $userAgent, bool $returnArray = false)
204			{
205			$this->setFormatter(new PhpGetBrowser($returnArray));
206			return $this->getBrowser($userAgent);
207			}
208			}
209

crossjoin / Browscap

Browscap::getFormatter() A last analyzed 2017-02-02 16:53 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Browscap::getFormatter() A
last analyzed 2017-02-02 16:53 UTC