Options::isSameValueAs() - Code Metrics - baleen/migrations - Measure and Improve Code Quality continuously with Scrutinizer

Options::isSameValueAs() B
last analyzed 2016-04-25 12:51 UTC

↳ Parent: Options

Complexity

Conditions	7
Paths	7

Size

Total Lines	13
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	7

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	13
ccs	9
cts	9
cp	1
rs	8.2222
cc	7
eloc	9
nc	7
nop	1
crap	7

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <https://github.com/baleen/migrations>.
 */

namespace Baleen\Migrations\Migration;

use Baleen\Migrations\Exception\InvalidArgumentException;
use Baleen\Migrations\Migration\Options\Direction;
use Baleen\Migrations\Common\ValueObjectInterface;

/**
 * @{inheritdoc}
 *
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 *
 * @author Gabriel Somoza <[email protected]>
 */
final class Options implements OptionsInterface
{
    /**
     * @var Direction
     */
    private $direction;

    /**
     * @var bool
     */
    private $forced;

    /**
     * @var bool
     */
    private $dryRun;

    /**
     * @var array
     */
    private $custom;

    /**
     * @var bool
     */
    private $exceptionOnSkip;

    /**
     * @param $direction
     * @param bool $forced
     * @param bool $dryRun
     * @param bool $exceptionOnSkip
     * @param array $custom
     *
     * @throws InvalidArgumentException
     */
    public function __construct(
        Direction $direction = null,
        $forced = false,
        $dryRun = false,
        $exceptionOnSkip = true,
        array $custom = []
    ) {
        if (null === $direction) {
            $direction = Direction::up();
        }
        $this->direction = $direction;

        $this->forced = (bool) $forced;
        $this->dryRun = (bool) $dryRun;
        $this->exceptionOnSkip = (bool) $exceptionOnSkip;
        $this->custom = $custom;
    }

    /**
     * getDirection
     *
     * @return Direction
     */
    public function getDirection()
    {
        return $this->direction;
    }

    /**
     * @param Direction $direction
     *
     * @return static
     *
     * @throws InvalidArgumentException
     */
    public function withDirection(Direction $direction)
    {
        return new static($direction, $this->forced, $this->dryRun, $this->exceptionOnSkip, $this->custom);
    }

    /**
     * @return bool
     */
    public function isForced()
    {
        return $this->forced;
    }

    /**
     * withForced
     * @param $forced
     * @return static
     */
    public function withForced($forced)
    {
        return new static($this->direction, $forced, $this->dryRun, $this->exceptionOnSkip, $this->custom);
    }

    /**
     * @return bool
     */
    public function isDryRun()
    {
        return $this->dryRun;
    }

    /**
     * withDryRun
     * @param bool $dryRun
     * @return static
     */
    public function withDryRun($dryRun)
    {
        return new static($this->direction, $this->forced, $dryRun, $this->exceptionOnSkip, $this->custom);
    }

    /**
     * @return bool
     */
    public function isExceptionOnSkip()
    {
        return $this->exceptionOnSkip;
    }

    /**
     * @param bool $exceptionOnSkip
     * @return static
     */
    public function withExceptionOnSkip($exceptionOnSkip)
    {
        return new static($this->direction, $this->forced, $this->dryRun, $exceptionOnSkip, $this->custom);
    }

    /**
     * @return array
     */
    public function getCustom()
    {
        return $this->custom;
    }

    /**
     * @param array $custom
     * @return static
     */
    public function withCustom(array $custom)
    {
        return new static($this->direction, $this->forced, $this->dryRun, $this->exceptionOnSkip, $custom);
    }

    /**
     * @inheritdoc
     */
    public function isSameValueAs(ValueObjectInterface $options)
    {
        if (!$options instanceof OptionsInterface) {
            return false;
        }

        return get_class($options) === get_class($this)
            && $this->getDirection()->isSameValueAs($options->getDirection())
            && $this->isForced() === $options->isForced()
            && $this->isDryRun() === $options->isDryRun()
            && $this->isExceptionOnSkip() === $options->isExceptionOnSkip()
            && $this->getCustom() == $options->getCustom();
    }

    /**
     * fromOptionsWithDirection
     *
     * @param Direction $direction
     * @param OptionsInterface|null $options
     *
     * @return static
     */
    public static function fromOptionsWithDirection(Direction $direction, OptionsInterface $options = null)
    {
        if (null === $options) {
            $options = (new static($direction))->withExceptionOnSkip(false);
        } else {
            $options = $options->withDirection($direction);
        }
        return $options;
    }

    /**
     * Returns a string representation of the object.
     *
     * @return string
     */
    public function __toString()
    {
        return __CLASS__ . '@' . spl_object_hash($this);
    }
}


1		<?php
2		/*
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the MIT license. For more information, see
17		* <https://github.com/baleen/migrations>.
18		*/
19
20		namespace Baleen\Migrations\Migration;
21
22		use Baleen\Migrations\Exception\InvalidArgumentException;
23		use Baleen\Migrations\Migration\Options\Direction;
24		use Baleen\Migrations\Common\ValueObjectInterface;
25
26		/**
27		* @{inheritdoc}
28		*
29		* @SuppressWarnings(PHPMD.TooManyPublicMethods)
30		*
31		* @author Gabriel Somoza <[email protected]>
32		*/
33		final class Options implements OptionsInterface
34		{
35		/**
36		* @var Direction
37		*/
38		private $direction;
39
40		/**
41		* @var bool
42		*/
43		private $forced;
44
45		/**
46		* @var bool
47		*/
48		private $dryRun;
49
50		/**
51		* @var array
52		*/
53		private $custom;
54
55		/**
56		* @var bool
57		*/
58		private $exceptionOnSkip;
59
60		/**
61		* @param $direction
62		* @param bool $forced
63		* @param bool $dryRun
64		* @param bool $exceptionOnSkip
65		* @param array $custom
66		*
67		* @throws InvalidArgumentException
68		*/
69	61	public function __construct(
70		Direction $direction = null,
71		$forced = false,
72		$dryRun = false,
73		$exceptionOnSkip = true,
74		array $custom = []
75		) {
76	61	if (null === $direction) {
77	28	$direction = Direction::up();
78	28	}
79	61	$this->direction = $direction;
80
81	61	$this->forced = (bool) $forced;
82	61	$this->dryRun = (bool) $dryRun;
83	61	$this->exceptionOnSkip = (bool) $exceptionOnSkip;
84	61	$this->custom = $custom;
85	61	}
86
87		/**
88		* getDirection
89		*
90		* @return Direction
91		*/
92	52	public function getDirection()
93		{
94	52	return $this->direction;
95		}
96
97		/**
98		* @param Direction $direction
99		*
100		* @return static
101		*
102		* @throws InvalidArgumentException
103		*/
104	17	public function withDirection(Direction $direction)
105		{
106	17	return new static($direction, $this->forced, $this->dryRun, $this->exceptionOnSkip, $this->custom);
107		}
108
109		/**
110		* @return bool
111		*/
112	40	public function isForced()
113		{
114	40	return $this->forced;
115		}
116
117		/**
118		* withForced
119		* @param $forced
120		* @return static
121		*/
122	1	public function withForced($forced)
123		{
124	1	return new static($this->direction, $forced, $this->dryRun, $this->exceptionOnSkip, $this->custom);
125		}
126
127		/**
128		* @return bool
129		*/
130	17	public function isDryRun()
131		{
132	17	return $this->dryRun;
133		}
134
135		/**
136		* withDryRun
137		* @param bool $dryRun
138		* @return static
139		*/
140	1	public function withDryRun($dryRun)
141		{
142	1	return new static($this->direction, $this->forced, $dryRun, $this->exceptionOnSkip, $this->custom);
143		}
144
145		/**
146		* @return bool
147		*/
148	30	public function isExceptionOnSkip()
149		{
150	30	return $this->exceptionOnSkip;
151		}
152
153		/**
154		* @param bool $exceptionOnSkip
155		* @return static
156		*/
157	20	public function withExceptionOnSkip($exceptionOnSkip)
158		{
159	20	return new static($this->direction, $this->forced, $this->dryRun, $exceptionOnSkip, $this->custom);
160		}
161
162		/**
163		* @return array
164		*/
165	14	public function getCustom()
166		{
167	14	return $this->custom;
168		}
169
170		/**
171		* @param array $custom
172		* @return static
173		*/
174	1	public function withCustom(array $custom)
175		{
176	1	return new static($this->direction, $this->forced, $this->dryRun, $this->exceptionOnSkip, $custom);
177		}
178
179		/**
180		* @inheritdoc
181		*/
182	7	public function isSameValueAs(ValueObjectInterface $options)
183		{
184	7	if (!$options instanceof OptionsInterface) {
185	1	return false;
186		}
187
188	6	return get_class($options) === get_class($this)
189	6	&& $this->getDirection()->isSameValueAs($options->getDirection())
190	6	&& $this->isForced() === $options->isForced()
191	6	&& $this->isDryRun() === $options->isDryRun()
192	6	&& $this->isExceptionOnSkip() === $options->isExceptionOnSkip()
193	6	&& $this->getCustom() == $options->getCustom();
194		}
195
196		/**
197		* fromOptionsWithDirection
198		*
199		* @param Direction $direction
200		* @param OptionsInterface\|null $options
201		*
202		* @return static
203		*/
204	10	public static function fromOptionsWithDirection(Direction $direction, OptionsInterface $options = null)
205		{
206	10	if (null === $options) {
207	1	$options = (new static($direction))->withExceptionOnSkip(false);
208	1	} else {
209	9	$options = $options->withDirection($direction);
210		}
211	10	return $options;
212		}
213
214		/**
215		* Returns a string representation of the object.
216		*
217		* @return string
218		*/
219	1	public function __toString()
220		{
221	1	return __CLASS__ . '@' . spl_object_hash($this);
222		}
223		}
224

baleen / migrations

Options::isSameValueAs() B last analyzed 2016-04-25 12:51 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Options::isSameValueAs() B
last analyzed 2016-04-25 12:51 UTC