Darksky::validateExcludes() - Code Metrics - Inspection of "Move lat and lng to the functions" - iranianpep/darksky - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0b97e0...dfe777 )

by Ehsan

created 2017-12-05 04:59 UTC

Darksky::validateExcludes() A

↳ Parent: Darksky

Complexity

Conditions	4
Paths	4

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	14
ccs	7
cts	7
cp	1
rs	9.2
c	0
b	0
f	0
cc	4
eloc	7
nc	4
nop	1
crap	4

<?php

namespace Darksky;

/**
 * Class Darksky.
 */
class Darksky
{
    const API_BASE_URL = 'https://api.darksky.net/forecast';
    const VALID_UNITS = [
        'auto',
        'ca',
        'uk2',
        'us',
        'si',
    ];

    const VALID_EXCLUDE = [
        'currently',
        'minutely',
        'hourly',
        'daily',
        'alerts',
        'flags',
    ];

    private $key;
    private $latitude;
    private $longitude;
    private $language;
    private $units;

    /**
     * Darksky constructor.
     *
     * @param        $key
     * @param string $lang
     * @param string $units
     */
    public function __construct(
        string $key,
        string $lang = 'en',
        string $units = 'auto'
    ) {
        $this->setKey($key);
        $this->setLanguage($lang);
        $this->setUnits($units);
    }

    /**
     * @param       $latitude
     * @param       $longitude
     * @param array $exclude
     * @param bool  $extend
     *
     * @throws \Exception
     *
     * @return string
     */
    public function forecast($latitude, $longitude, array $exclude = [], $extend = false)
    {
        try {
            return file_get_contents($this->generateRequestUrl($latitude, $longitude, $exclude, $extend));
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * @param $latitude
     * @param $longitude
     * @param $time
     * @param array $exclude
     *
     * @throws \Exception
     *
     * @return bool|string
     */
    public function timeMachine($latitude, $longitude, string $time, array $exclude = [])
    {
        try {
            return file_get_contents($this->generateRequestUrl($latitude, $longitude, $exclude, false, $time));
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * @return string
     */
    public function getKey(): string
    {
        return $this->key;
    }

    /**
     * @param string $key
     */
    public function setKey(string $key)
    {
        $this->key = $key;
    }

    /**
     * @param array  $exclude
     * @param bool   $extend
     * @param string $time
     *
     * @return string
     */
    private function generateRequestUrl($latitude, $longitude, array $exclude = [], $extend = false, string $time = ''): string
    {
        if (!empty($time)) {
            $time = ",{$time}";
        }

        return self::API_BASE_URL.'/'.$this->getKey().'/'.$latitude.','.$longitude.$time
            .'?'.$this->generateUrlQueryString($exclude, $extend);
    }

    /**
     * @param array $exclude
     * @param bool  $extend
     *
     * @throws \Exception
     *
     * @return string
     */
    private function generateUrlQueryString(array $exclude = [], $extend = false): string
    {
        $queryString = ['lang' => $this->getLanguage(), 'units' => $this->getUnits()];

        // validate $exclude
        if ($this->validateExcludes($exclude) !== true) {
            $validExcludes = implode(',', self::VALID_EXCLUDE);

            throw new DarkskyException("Invalid excludes. Provide valid excludes: {$validExcludes}'");
        }

        if (!empty($exclude)) {
            $queryString['exclude'] = implode(',', $exclude);
        }

        if ($extend === true) {
            $queryString['extend'] = 'hourly';
        }

        return http_build_query($queryString);
    }

    /**
     * @param $exclude
     *
     * @return bool
     */
    private function validateExcludes(array $exclude): bool
    {
        if (empty($exclude)) {
            return true;
        }

        foreach ($exclude as $anExclude) {
            if (!in_array($anExclude, self::VALID_EXCLUDE)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return string
     */
    public function getLanguage(): string
    {
        return $this->language;
    }

    /**
     * @param string $language
     */
    public function setLanguage(string $language)
    {
        $this->language = $language;
    }

    /**
     * @return string
     */
    public function getUnits(): string
    {
        return $this->units;
    }

    /**
     * @param $units
     *
     * @throws \Exception
     */
    public function setUnits(string $units)
    {
        if (!in_array($units, self::VALID_UNITS)) {
            $validUnits = implode(',', self::VALID_UNITS);

            throw new DarkskyException("'{$units}' is not a valid unit. Valid units: {$validUnits}");
        }

        $this->units = $units;
    }
}


1		<?php
2
3		namespace Darksky;
4
5		/**
6		* Class Darksky.
7		*/
8		class Darksky
9		{
10		const API_BASE_URL = 'https://api.darksky.net/forecast';
11		const VALID_UNITS = [
12		'auto',
13		'ca',
14		'uk2',
15		'us',
16		'si',
17		];
18
19		const VALID_EXCLUDE = [
20		'currently',
21		'minutely',
22		'hourly',
23		'daily',
24		'alerts',
25		'flags',
26		];
27
28		private $key;
29		private $latitude;
30		private $longitude;
31		private $language;
32		private $units;
33
34		/**
35		* Darksky constructor.
36		*
37		* @param $key
38		* @param string $lang
39		* @param string $units
40		*/
41	7	public function __construct(
42		string $key,
43		string $lang = 'en',
44		string $units = 'auto'
45		) {
46	7	$this->setKey($key);
47	7	$this->setLanguage($lang);
48	7	$this->setUnits($units);
49	7	}
50
51		/**
52		* @param $latitude
53		* @param $longitude
54		* @param array $exclude
55		* @param bool $extend
56		*
57		* @throws \Exception
58		*
59		* @return string
60		*/
61	3	public function forecast($latitude, $longitude, array $exclude = [], $extend = false)
62		{
63		try {
64	3	return file_get_contents($this->generateRequestUrl($latitude, $longitude, $exclude, $extend));
65	3	} catch (\Exception $e) {
66	3	throw $e;
67		}
68		}
69
70		/**
71		* @param $latitude
72		* @param $longitude
73		* @param $time
74		* @param array $exclude
75		*
76		* @throws \Exception
77		*
78		* @return bool\|string
79		*/
80	1	public function timeMachine($latitude, $longitude, string $time, array $exclude = [])
81		{
82		try {
83	1	return file_get_contents($this->generateRequestUrl($latitude, $longitude, $exclude, false, $time));
84	1	} catch (\Exception $e) {
85	1	throw $e;
86		}
87		}
88
89		/**
90		* @return string
91		*/
92	5	public function getKey(): string
93		{
94	5	return $this->key;
95		}
96
97		/**
98		* @param string $key
99		*/
100	7	public function setKey(string $key)
101		{
102	7	$this->key = $key;
103	7	}
104
105		/**
106		* @param array $exclude
107		* @param bool $extend
108		* @param string $time
109		*
110		* @return string
111		*/
112	4	private function generateRequestUrl($latitude, $longitude, array $exclude = [], $extend = false, string $time = ''): string
113		{
114	4	if (!empty($time)) {
115	1	$time = ",{$time}";
116		}
117
118	4	return self::API_BASE_URL.'/'.$this->getKey().'/'.$latitude.','.$longitude.$time
119	4	.'?'.$this->generateUrlQueryString($exclude, $extend);
120		}
121
122		/**
123		* @param array $exclude
124		* @param bool $extend
125		*
126		* @throws \Exception
127		*
128		* @return string
129		*/
130	4	private function generateUrlQueryString(array $exclude = [], $extend = false): string
131		{
132	4	$queryString = ['lang' => $this->getLanguage(), 'units' => $this->getUnits()];
133
134		// validate $exclude
135	4	if ($this->validateExcludes($exclude) !== true) {
136	1	$validExcludes = implode(',', self::VALID_EXCLUDE);
137
138	1	throw new DarkskyException("Invalid excludes. Provide valid excludes: {$validExcludes}'");
139		}
140
141	3	if (!empty($exclude)) {
142	1	$queryString['exclude'] = implode(',', $exclude);
143		}
144
145	3	if ($extend === true) {
146	2	$queryString['extend'] = 'hourly';
147		}
148
149	3	return http_build_query($queryString);
150		}
151
152		/**
153		* @param $exclude
154		*
155		* @return bool
156		*/
157	4	private function validateExcludes(array $exclude): bool
158		{
159	4	if (empty($exclude)) {
160	2	return true;
161		}
162
163	2	foreach ($exclude as $anExclude) {
164	2	if (!in_array($anExclude, self::VALID_EXCLUDE)) {
165	2	return false;
166		}
167		}
168
169	1	return true;
170		}
171
172		/**
173		* @return string
174		*/
175	5	public function getLanguage(): string
176		{
177	5	return $this->language;
178		}
179
180		/**
181		* @param string $language
182		*/
183	7	public function setLanguage(string $language)
184		{
185	7	$this->language = $language;
186	7	}
187
188		/**
189		* @return string
190		*/
191	5	public function getUnits(): string
192		{
193	5	return $this->units;
194		}
195
196		/**
197		* @param $units
198		*
199		* @throws \Exception
200		*/
201	7	public function setUnits(string $units)
202		{
203	7	if (!in_array($units, self::VALID_UNITS)) {
204	1	$validUnits = implode(',', self::VALID_UNITS);
205
206	1	throw new DarkskyException("'{$units}' is not a valid unit. Valid units: {$validUnits}");
207		}
208
209	7	$this->units = $units;
210	7	}
211		}
212

iranianpep / darksky

Push — master ( 0b97e0...dfe777 )

Darksky::validateExcludes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like