Version::setMajor() - Code Metrics - Inspection of "Daily Inspection: Merge remote-tracking branch 'gi..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — TASK/11208/update-bundled-gate... (60edbd)

unknown

created 2017-12-07 21:07 UTC

Version::setMajor() A

↳ Parent: Version

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	7

Duplication

Lines	11
Ratio	100 %

Importance

Changes

Metric	Value
cc	2
eloc	7
nc	2
nop	1
dl	11
loc	11
rs	9.4285
c	0
b	0
f	0

<?php

namespace EventEspresso\core\domain\values;

use EventEspresso\core\exceptions\InvalidDataTypeException;
use InvalidArgumentException;

defined('EVENT_ESPRESSO_VERSION') || exit;



/**
 * Class Version
 * Value Object representing a valid PHP version string for an Event Espresso product
 *
 * @package EventEspresso\core\domain\values
 * @author  Brent Christensen
 * @since   4.9.51
 */
class Version
{

    const RELEASE_TYPE_RC    = 'rc';

    const RELEASE_TYPE_BETA  = 'beta';

    const RELEASE_TYPE_DECAF = 'decaf';

    const RELEASE_TYPE_PROD  = 'p';

    /**
     * @var int $major
     */
    private $major;

    /**
     * @var int $minor
     */
    private $minor;

    /**
     * @var int $patch
     */
    private $patch;

    /**
     * @var string $release
     */
    private $release;

    /**
     * @var int $build
     */
    private $build;


    /**
     * Version constructor.
     *
     * @param int    $major
     * @param int    $minor
     * @param int    $patch
     * @param string $release
     * @param int    $build
     * @throws InvalidDataTypeException
     * @throws InvalidArgumentException
     */
    public function __construct($major, $minor, $patch, $release = Version::RELEASE_TYPE_PROD, $build = 0)
    {
        $this->setMajor($major);
        $this->setMinor($minor);
        $this->setPatch($patch);
        $this->setRelease($release);
        $this->setBuild($build);
    }


    /**
     * @param string $version_string
     * @return Version
     * @throws InvalidArgumentException
     */
    public static function fromString($version_string)
    {
        // compare incoming version string against the lowest possible valid version
        if (version_compare($version_string, '0.0.1.dev.001', '<')) {
            throw new InvalidArgumentException(
                sprintf(
                    esc_html__('"%1$s" is not a valid version string', 'event_espresso'),
                    $version_string
                )
            );
        }
        // break apart incoming version string
        $version_parts = explode('.', $version_string);
        // verify that version string at least contains {major}.{minor}.{patch}
        if (count($version_parts) < 3) {
            throw new InvalidArgumentException(
                sprintf(
                    esc_html__(
                        'At minimum, a version string needs to be in a "{major}.{minor}.{patch}" format, therefore "%1$s" is not valid',
                        'event_espresso'
                    ),
                    $version_string
                )
            );
        }
        // add defaults for missing pieces
        $version_parts += array(0,0,0,'p',0);
        // reassign to individual variables
        list($major, $minor, $patch, $release, $build) = $version_parts;
        return new Version(
            (int) $major,
            (int) $minor,
            (int) $patch,
            $release,
            (int) $build
        );
    }


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


    /**
     * @param int|string $major
     * @throws InvalidDataTypeException
     */
    private function setMajor($major)
    {
        if (! is_int($major)) {
            throw new InvalidDataTypeException(
                '$major',
                $major,
                'integer'
            );
        }
        $this->major = absint($major);
    }


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


    /**
     * @param int|string $minor
     * @throws InvalidDataTypeException
     */
    private function setMinor($minor)
    {
        if (! is_int($minor)) {
            throw new InvalidDataTypeException(
                '$minor',
                $minor,
                'integer'
            );
        }
        $this->minor = absint($minor);
    }


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


    /**
     * @param int|string $patch
     * @throws InvalidDataTypeException
     */
    private function setPatch($patch)
    {
        if (! is_int($patch)) {
            throw new InvalidDataTypeException(
                '$patch',
                $patch,
                'integer'
            );
        }
        $this->patch = absint($patch);
    }


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


    /**
     * @param string $release
     * @throws InvalidArgumentException
     */
    private function setRelease($release)
    {
        $valid_release_types = array(
            Version::RELEASE_TYPE_RC,
            Version::RELEASE_TYPE_BETA,
            Version::RELEASE_TYPE_DECAF,
            Version::RELEASE_TYPE_PROD,
        );
        if (! in_array($release, $valid_release_types, true)) {
            throw new InvalidArgumentException(
                sprintf(
                    esc_html__(
                        '"%1$s" is not a valid release type. Please use one of the following values: %2$s',
                        'event_espresso'
                    ),
                    $release,
                    implode(', ', $valid_release_types)
                )
            );
        }
        $this->release = $release;
    }


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


    /**
     * @param int|string $build
     * @throws InvalidDataTypeException
     */
    private function setBuild($build)
    {
        if (! is_int($build)) {
            throw new InvalidDataTypeException(
                '$build',
                $build,
                'integer'
            );
        }
        $this->build = absint($build);
    }


    /**
     * @param Version $other_version
     * @return int
     */
    public function compare(Version $other_version)
    {
        return version_compare((string) $this, (string) $other_version);
    }


    /**
     * @param Version $other_version
     * @return bool
     */
    public function equals(Version $other_version)
    {
        return version_compare((string) $this, (string) $other_version, '==');
    }


    /**
     * @param Version $other_version
     * @return bool
     */
    public function newerThan(Version $other_version)
    {
        return version_compare((string) $this, (string) $other_version, '>');
    }


    /**
     * @param Version $other_version
     * @return bool
     */
    public function olderThan(Version $other_version)
    {
        return version_compare((string) $this, (string) $other_version, '<');
    }


    /**
     * @return string
     */
    public function __toString()
    {
        $version_string = "{$this->major}.{$this->minor}.{$this->patch}.{$this->release}";
        if($this->release !== Version::RELEASE_TYPE_PROD && $this->release !== Version::RELEASE_TYPE_DECAF) {
            $version_string .= '.' . str_pad($this->build, 3, '0', STR_PAD_LEFT);
        }
        return $version_string;
    }



}
// Location: Version.php


1		<?php
2
3		namespace EventEspresso\core\domain\values;
4
5		use EventEspresso\core\exceptions\InvalidDataTypeException;
6		use InvalidArgumentException;
7
8		defined('EVENT_ESPRESSO_VERSION') \|\| exit;
9
10
11
12		/**
13		* Class Version
14		* Value Object representing a valid PHP version string for an Event Espresso product
15		*
16		* @package EventEspresso\core\domain\values
17		* @author Brent Christensen
18		* @since 4.9.51
19		*/
20		class Version
21		{
22
23		const RELEASE_TYPE_RC = 'rc';
24
25		const RELEASE_TYPE_BETA = 'beta';
26
27		const RELEASE_TYPE_DECAF = 'decaf';
28
29		const RELEASE_TYPE_PROD = 'p';
30
31		/**
32		* @var int $major
33		*/
34		private $major;
35
36		/**
37		* @var int $minor
38		*/
39		private $minor;
40
41		/**
42		* @var int $patch
43		*/
44		private $patch;
45
46		/**
47		* @var string $release
48		*/
49		private $release;
50
51		/**
52		* @var int $build
53		*/
54		private $build;
55
56
57		/**
58		* Version constructor.
59		*
60		* @param int $major
61		* @param int $minor
62		* @param int $patch
63		* @param string $release
64		* @param int $build
65		* @throws InvalidDataTypeException
66		* @throws InvalidArgumentException
67		*/
68		public function __construct($major, $minor, $patch, $release = Version::RELEASE_TYPE_PROD, $build = 0)
69		{
70		$this->setMajor($major);
71		$this->setMinor($minor);
72		$this->setPatch($patch);
73		$this->setRelease($release);
74		$this->setBuild($build);
75		}
76
77
78		/**
79		* @param string $version_string
80		* @return Version
81		* @throws InvalidArgumentException
82		*/
83		public static function fromString($version_string)
84		{
85		// compare incoming version string against the lowest possible valid version
86		if (version_compare($version_string, '0.0.1.dev.001', '<')) {
87		throw new InvalidArgumentException(
88		sprintf(
89		esc_html__('"%1$s" is not a valid version string', 'event_espresso'),
90		$version_string
91		)
92		);
93		}
94		// break apart incoming version string
95		$version_parts = explode('.', $version_string);
96		// verify that version string at least contains {major}.{minor}.{patch}
97		if (count($version_parts) < 3) {
98		throw new InvalidArgumentException(
99		sprintf(
100		esc_html__(
101		'At minimum, a version string needs to be in a "{major}.{minor}.{patch}" format, therefore "%1$s" is not valid',
102		'event_espresso'
103		),
104		$version_string
105		)
106		);
107		}
108		// add defaults for missing pieces
109		$version_parts += array(0,0,0,'p',0);
110		// reassign to individual variables
111		list($major, $minor, $patch, $release, $build) = $version_parts;
112		return new Version(
113		(int) $major,
114		(int) $minor,
115		(int) $patch,
116		$release,
117		(int) $build
118		);
119		}
120
121
122		/**
123		* @return int
124		*/
125		public function major()
126		{
127		return $this->major;
128		}
129
130
131		/**
132		* @param int\|string $major
133		* @throws InvalidDataTypeException
134		*/
135	View Code Duplication	private function setMajor($major)
136		{
137		if (! is_int($major)) {
138		throw new InvalidDataTypeException(
139		'$major',
140		$major,
141		'integer'
142		);
143		}
144		$this->major = absint($major);
145		}
146
147
148		/**
149		* @return int
150		*/
151		public function minor()
152		{
153		return $this->minor;
154		}
155
156
157		/**
158		* @param int\|string $minor
159		* @throws InvalidDataTypeException
160		*/
161	View Code Duplication	private function setMinor($minor)
162		{
163		if (! is_int($minor)) {
164		throw new InvalidDataTypeException(
165		'$minor',
166		$minor,
167		'integer'
168		);
169		}
170		$this->minor = absint($minor);
171		}
172
173
174		/**
175		* @return int
176		*/
177		public function patch()
178		{
179		return $this->patch;
180		}
181
182
183		/**
184		* @param int\|string $patch
185		* @throws InvalidDataTypeException
186		*/
187	View Code Duplication	private function setPatch($patch)
188		{
189		if (! is_int($patch)) {
190		throw new InvalidDataTypeException(
191		'$patch',
192		$patch,
193		'integer'
194		);
195		}
196		$this->patch = absint($patch);
197		}
198
199
200		/**
201		* @return string
202		*/
203		public function release()
204		{
205		return $this->release;
206		}
207
208
209		/**
210		* @param string $release
211		* @throws InvalidArgumentException
212		*/
213		private function setRelease($release)
214		{
215		$valid_release_types = array(
216		Version::RELEASE_TYPE_RC,
217		Version::RELEASE_TYPE_BETA,
218		Version::RELEASE_TYPE_DECAF,
219		Version::RELEASE_TYPE_PROD,
220		);
221	View Code Duplication	if (! in_array($release, $valid_release_types, true)) {
222		throw new InvalidArgumentException(
223		sprintf(
224		esc_html__(
225		'"%1$s" is not a valid release type. Please use one of the following values: %2$s',
226		'event_espresso'
227		),
228		$release,
229		implode(', ', $valid_release_types)
230		)
231		);
232		}
233		$this->release = $release;
234		}
235
236
237		/**
238		* @return int
239		*/
240		public function build()
241		{
242		return $this->build;
243		}
244
245
246		/**
247		* @param int\|string $build
248		* @throws InvalidDataTypeException
249		*/
250	View Code Duplication	private function setBuild($build)
251		{
252		if (! is_int($build)) {
253		throw new InvalidDataTypeException(
254		'$build',
255		$build,
256		'integer'
257		);
258		}
259		$this->build = absint($build);
260		}
261
262
263		/**
264		* @param Version $other_version
265		* @return int
266		*/
267		public function compare(Version $other_version)
268		{
269		return version_compare((string) $this, (string) $other_version);
270		}
271
272
273		/**
274		* @param Version $other_version
275		* @return bool
276		*/
277		public function equals(Version $other_version)
278		{
279		return version_compare((string) $this, (string) $other_version, '==');
280		}
281
282
283		/**
284		* @param Version $other_version
285		* @return bool
286		*/
287		public function newerThan(Version $other_version)
288		{
289		return version_compare((string) $this, (string) $other_version, '>');
290		}
291
292
293		/**
294		* @param Version $other_version
295		* @return bool
296		*/
297		public function olderThan(Version $other_version)
298		{
299		return version_compare((string) $this, (string) $other_version, '<');
300		}
301
302
303		/**
304		* @return string
305		*/
306		public function __toString()
307		{
308		$version_string = "{$this->major}.{$this->minor}.{$this->patch}.{$this->release}";
309		if($this->release !== Version::RELEASE_TYPE_PROD && $this->release !== Version::RELEASE_TYPE_DECAF) {
310		$version_string .= '.' . str_pad($this->build, 3, '0', STR_PAD_LEFT);
311		}
312		return $version_string;
313		}
314
315
316
317		}
318		// Location: Version.php
319

eventespresso / event-espresso-core

Branch — TASK/11208/update-bundled-gate... (60edbd)

Version::setMajor() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like