Device::__construct() - Code Metrics - serbanghita/Mobile-Detect - Measure and Improve Code Quality continuously with Scrutinizer

Device::__construct() A
last analyzed 2015-12-26 20:57 UTC

↳ Parent: Device

Complexity

Conditions	1
Paths	1

Size

Total Lines	21
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	2

Metric	Value
c	3
b	0
f	2
dl	0
loc	21
rs	9.3143
cc	1
eloc	19
nc	1
nop	9

How to fix Many Parameters

<?php
namespace MobileDetect\Device;

use MobileDetect\Exception\InvalidDeviceSpecificationException;

/**
 * Class Device
 *
 * Defines properties for a particular device.
 */
class Device implements DeviceInterface
{

    /**
     * A list of required keys for the factory method.
     *
     * @var array
     */
    public static $requiredFields = array(
        'deviceType',
        'userAgent'
    );    
    
    /**
     * One of the TYPE_* constants.
     *
     * @var int
     */
    protected $type;

    /**
     * The 'User-Agent' header as a string.
     *
     * @var string
     */
    protected $userAgent;

    /**
     * The model of this device, such as Samsung, Chromebook, iPhone, or ...
     *
     * @var string
     */
    protected $model;

    /**
     * Version of the particular model, such as 5S for the iPhone 5S.
     *
     * @var string
     */
    protected $modelVersion;

    /**
     * The operating system, such as 'Windows' or 'iOS'.
     *
     * @var string
     */
    protected $operatingSystem;

    /**
     * The OS version.
     *
     * @var string
     */
    protected $operatingSystemVersion;

    /**
     * The browser. If this is a bot, then this value is populated with the bot identifier, such as
     * "facebookexternalhit" for Facebook crawling or "GoogleBot" for the Google.
     *
     * @var string
     */
    protected $browser;

    /**
     * The version of the browser (or bot crawler).
     *
     * @var string
     */
    protected $browserVersion;

    /**
     * The vendor name for this device.
     *
     * @var string
     */
    protected $vendor;

    /**
     * @param $userAgent
     * @param $deviceType
     * @param $deviceModel
     * @param $deviceModelVersion
     * @param $operatingSystemModel
     * @param $operatingSystemVersion
     * @param $browserModel
     * @param $browserVersion
     * @param $vendor
     */
    public function __construct(
        $userAgent,
        $deviceType,
        $deviceModel,
        $deviceModelVersion,
        $operatingSystemModel,
        $operatingSystemVersion,
        $browserModel,
        $browserVersion,
        $vendor
    ) {
        $this->userAgent = $userAgent;
        $this->type = $deviceType;
        $this->model = $deviceModel;
        $this->modelVersion = $deviceModelVersion;
        $this->operatingSystem = $operatingSystemModel;
        $this->operatingSystemVersion = $operatingSystemVersion;
        $this->browser = $browserModel;
        $this->browserVersion = $browserVersion;
        $this->vendor = $vendor;
    }

    /**
     * Retrieves the type of device.
     *
     * @return int
     */
    public function getType()
    {
        return $this->type;
    }

    public function getModel()
    {
        return $this->model;
    }

    public function getModelVersion()
    {
        return $this->modelVersion;
    }

    public function getOperatingSystem()
    {
        return $this->operatingSystem;
    }

    public function getOperatingSystemVersion()
    {
        return $this->operatingSystemVersion;
    }

    public function getBrowser()
    {
        return $this->browser;
    }

    public function getBrowserVersion()
    {
        return $this->browserVersion;
    }

    public function getVendor()
    {
        return $this->vendor;
    }

    public function getUserAgent()
    {
        return $this->userAgent;
    }

    public function isMobile()
    {
        return $this->type == DeviceType::MOBILE || $this->type == DeviceType::TABLET;
    }

    public function isDesktop()
    {
        return $this->type == DeviceType::DESKTOP;
    }

    public function isTablet()
    {
        return $this->type == DeviceType::TABLET;
    }

    public function isBot()
    {
        return $this->type == DeviceType::BOT;
    }

    public function toArray()
    {
        return array(
            'type'                      => $this->getType(),
            'isMobile'                  => $this->isMobile(),
            'isTablet'                  => $this->isTablet(),
            'isDesktop'                 => $this->isDesktop(),
            'isBot'                     => $this->isBot(),
            'browser'                   => $this->getBrowser(),
            'browserVersion'            => $this->getBrowserVersion(),
            'model'                     => $this->getModel(),
            'modelVersion'              => $this->getModelVersion(),
            'operatingSystem'           => $this->getOperatingSystem(),
            'operatingSystemVersion'    => $this->getOperatingSystemVersion(),
            'userAgent'                 => $this->getUserAgent(),
            'vendor'                    => $this->getVendor(),
        );
    }

    /**
     * @param array $prop   An array of properties to create this device from.
     * @return Device The device instance.
     * @throws InvalidDeviceSpecificationException When insufficient properties are present to
     *                                                       identify this device.
     */
    public static function create(array $prop)
    {
        // ensure that all the required keys are present
        foreach (self::$requiredFields as $key) {
            if (!isset($prop[$key])) {
                throw new InvalidDeviceSpecificationException(sprintf("The '%s' property is required.", $key));
            }
        }

        // check that a valid type was passed
        if ($prop['deviceType'] != DeviceType::DESKTOP
            && $prop['deviceType'] != DeviceType::MOBILE
            && $prop['deviceType'] != DeviceType::TABLET
            && $prop['deviceType'] != DeviceType::BOT
        ) {
            throw new InvalidDeviceSpecificationException(
                sprintf("Unrecognized type: '%s'", $prop['deviceType'])
            );
        }

        // create a new instance
        return new static(
            $prop['userAgent'],
            $prop['deviceType'], $prop['deviceModel'], $prop['deviceModelVersion'],
            $prop['operatingSystemModel'], $prop['operatingSystemVersion'],
            $prop['browserModel'], $prop['browserVersion'],
            $prop['vendor']
        );
    }
}

1			<?php
2			namespace MobileDetect\Device;
3
4			use MobileDetect\Exception\InvalidDeviceSpecificationException;
5
6			/**
7			* Class Device
8			*
9			* Defines properties for a particular device.
10			*/
11			class Device implements DeviceInterface
12			{
13
14			/**
15			* A list of required keys for the factory method.
16			*
17			* @var array
18			*/
19			public static $requiredFields = array(
20			'deviceType',
21			'userAgent'
22			);
23
24			/**
25			* One of the TYPE_* constants.
26			*
27			* @var int
28			*/
29			protected $type;
30
31			/**
32			* The 'User-Agent' header as a string.
33			*
34			* @var string
35			*/
36			protected $userAgent;
37
38			/**
39			* The model of this device, such as Samsung, Chromebook, iPhone, or ...
40			*
41			* @var string
42			*/
43			protected $model;
44
45			/**
46			* Version of the particular model, such as 5S for the iPhone 5S.
47			*
48			* @var string
49			*/
50			protected $modelVersion;
51
52			/**
53			* The operating system, such as 'Windows' or 'iOS'.
54			*
55			* @var string
56			*/
57			protected $operatingSystem;
58
59			/**
60			* The OS version.
61			*
62			* @var string
63			*/
64			protected $operatingSystemVersion;
65
66			/**
67			* The browser. If this is a bot, then this value is populated with the bot identifier, such as
68			* "facebookexternalhit" for Facebook crawling or "GoogleBot" for the Google.
69			*
70			* @var string
71			*/
72			protected $browser;
73
74			/**
75			* The version of the browser (or bot crawler).
76			*
77			* @var string
78			*/
79			protected $browserVersion;
80
81			/**
82			* The vendor name for this device.
83			*
84			* @var string
85			*/
86			protected $vendor;
87
88			/**
89			* @param $userAgent
90			* @param $deviceType
91			* @param $deviceModel
92			* @param $deviceModelVersion
93			* @param $operatingSystemModel
94			* @param $operatingSystemVersion
95			* @param $browserModel
96			* @param $browserVersion
97			* @param $vendor
98			*/
99			public function __construct(
100			$userAgent,
101			$deviceType,
102			$deviceModel,
103			$deviceModelVersion,
104			$operatingSystemModel,
105			$operatingSystemVersion,
106			$browserModel,
107			$browserVersion,
108			$vendor
109			) {
110			$this->userAgent = $userAgent;
111			$this->type = $deviceType;
112			$this->model = $deviceModel;
113			$this->modelVersion = $deviceModelVersion;
114			$this->operatingSystem = $operatingSystemModel;
115			$this->operatingSystemVersion = $operatingSystemVersion;
116			$this->browser = $browserModel;
117			$this->browserVersion = $browserVersion;
118			$this->vendor = $vendor;
119			}
120
121			/**
122			* Retrieves the type of device.
123			*
124			* @return int
125			*/
126			public function getType()
127			{
128			return $this->type;
129			}
130
131			public function getModel()
132			{
133			return $this->model;
134			}
135
136			public function getModelVersion()
137			{
138			return $this->modelVersion;
139			}
140
141			public function getOperatingSystem()
142			{
143			return $this->operatingSystem;
144			}
145
146			public function getOperatingSystemVersion()
147			{
148			return $this->operatingSystemVersion;
149			}
150
151			public function getBrowser()
152			{
153			return $this->browser;
154			}
155
156			public function getBrowserVersion()
157			{
158			return $this->browserVersion;
159			}
160
161			public function getVendor()
162			{
163			return $this->vendor;
164			}
165
166			public function getUserAgent()
167			{
168			return $this->userAgent;
169			}
170
171			public function isMobile()
172			{
173			return $this->type == DeviceType::MOBILE \|\| $this->type == DeviceType::TABLET;
174			}
175
176			public function isDesktop()
177			{
178			return $this->type == DeviceType::DESKTOP;
179			}
180
181			public function isTablet()
182			{
183			return $this->type == DeviceType::TABLET;
184			}
185
186			public function isBot()
187			{
188			return $this->type == DeviceType::BOT;
189			}
190
191			public function toArray()
192			{
193			return array(
194			'type' => $this->getType(),
195			'isMobile' => $this->isMobile(),
196			'isTablet' => $this->isTablet(),
197			'isDesktop' => $this->isDesktop(),
198			'isBot' => $this->isBot(),
199			'browser' => $this->getBrowser(),
200			'browserVersion' => $this->getBrowserVersion(),
201			'model' => $this->getModel(),
202			'modelVersion' => $this->getModelVersion(),
203			'operatingSystem' => $this->getOperatingSystem(),
204			'operatingSystemVersion' => $this->getOperatingSystemVersion(),
205			'userAgent' => $this->getUserAgent(),
206			'vendor' => $this->getVendor(),
207			);
208			}
209
210			/**
211			* @param array $prop An array of properties to create this device from.
212			* @return Device The device instance.
213			* @throws InvalidDeviceSpecificationException When insufficient properties are present to
214			* identify this device.
215			*/
216			public static function create(array $prop)
217			{
218			// ensure that all the required keys are present
219			foreach (self::$requiredFields as $key) {
220			if (!isset($prop[$key])) {
221			throw new InvalidDeviceSpecificationException(sprintf("The '%s' property is required.", $key));
222			}
223			}
224
225			// check that a valid type was passed
226			if ($prop['deviceType'] != DeviceType::DESKTOP
227			&& $prop['deviceType'] != DeviceType::MOBILE
228			&& $prop['deviceType'] != DeviceType::TABLET
229			&& $prop['deviceType'] != DeviceType::BOT
230			) {
231			throw new InvalidDeviceSpecificationException(
232			sprintf("Unrecognized type: '%s'", $prop['deviceType'])
233			);
234			}
235
236			// create a new instance
237			return new static(
238			$prop['userAgent'],
239			$prop['deviceType'], $prop['deviceModel'], $prop['deviceModelVersion'],
240			$prop['operatingSystemModel'], $prop['operatingSystemVersion'],
241			$prop['browserModel'], $prop['browserVersion'],
242			$prop['vendor']
243			);
244			}
245			}

serbanghita / Mobile-Detect

Device::__construct() A last analyzed 2015-12-26 20:57 UTC

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like

Device::__construct() A
last analyzed 2015-12-26 20:57 UTC