Numbers - Code Metrics - Inspection of "Cleaned up some of the interfaces, fixed logic pro..." - JordanRL/Fermat - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( a4ab81...299db4 )

by Jordan

created 2017-01-09 10:19 UTC

Numbers B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	247
Duplicated Lines	25.1 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

Metric	Value
wmc	42
lcom	1
cbo	6
dl	62
loc	247
rs	8.295
c	0
b	0
f	0

11 Methods

Rating	Name	Duplication	Size	Complexity
B	make()	0	27	6
A	makeFromBase10()	0	9	1
C	makeOrDont()	0	28	7
B	makeFractionFromString()	0	27	5
B	makePi()	16	16	5
B	makeTau()	14	14	5
A	make2Pi()	0	4	1
B	makeE()	16	16	5
B	makeGoldenRatio()	16	16	5
A	makeOne()	0	4	1
A	makeZero()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Numbers often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Numbers, and based on these observations, apply Extract Interface, too.

<?php

namespace Samsara\Fermat;

use Samsara\Exceptions\UsageError\IntegrityConstraint;
use Samsara\Fermat\Values\ImmutableFraction;
use Samsara\Fermat\Values\ImmutableNumber;
use Samsara\Fermat\Values\MutableFraction;
use Samsara\Fermat\Values\MutableNumber;
use Samsara\Fermat\Types\Base\NumberInterface;

class Numbers
{

    const MUTABLE = MutableNumber::class;
    const IMMUTABLE = ImmutableNumber::class;
    const MUTABLE_FRACTION = MutableFraction::class;
    const IMMUTABLE_FRACTION = ImmutableFraction::class;
    /* 105 digits after decimal, which is going to be overkill in almost all places */
    const PI = '3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148';
    /* Tau (2pi) to 100 digits */
    const TAU = '6.283185307179586476925286766559005768394338798750211641949889184615632812572417997256069650684234136';
    /* Euler's Number to 100 digits */
    const E = '2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427';
    /* Golden Ratio to 100 digits */
    const GOLDEN_RATIO = '1.618033988749894848204586834365638117720309179805762862135448622705260462818902449707207204189391137';

    /**
     * @param $type
     * @param $value
     * @param int|null $precision
     * @param int $base
     * @return ImmutableNumber|MutableNumber|ImmutableFraction|MutableFraction|NumberInterface
     */
    public static function make($type, $value, $precision = null, $base = 10)
    {

        if ($type == self::IMMUTABLE) {
            return new ImmutableNumber(trim($value), $precision, $base);
        } elseif ($type == self::MUTABLE) {
            return new MutableNumber(trim($value), $precision, $base);
        } elseif ($type == self::IMMUTABLE_FRACTION) {
            return self::makeFractionFromString($value, $type)->convertToBase($base);
        } elseif ($type == self::MUTABLE_FRACTION) {
            return self::makeFractionFromString($value, $type)->convertToBase($base);
        } else {
            $reflector = new \ReflectionClass($type);

            if ($reflector->implementsInterface(NumberInterface::class)) {
                /** @var NumberInterface $customNumber */
                $customNumber = $reflector->newInstance([
                    trim($value),
                    $precision,
                    $base
                ]);
                return $customNumber;
            }
        }

        throw new \InvalidArgumentException('The $type argument was not an implementation of NumberInterface.');
    }

    /**
     * @param $type
     * @param $value
     * @param int|null $precision
     * @param int $base
     * @return NumberInterface
     */
    public static function makeFromBase10($type, $value, $precision = null, $base = 10)
    {
        /**
         * @var ImmutableNumber|MutableNumber
         */
        $number = self::make($type, $value, $precision, 10);

        return $number->convertToBase($base);
    }

    /**
     * @param $type
     * @param int|float|string|NumberInterface $value
     * @param int|null $precision
     * @param int $base
     *
*@throws \InvalidArgumentException
     * @return ImmutableNumber|MutableNumber|NumberInterface|ImmutableNumber[]|MutableNumber[]|NumberInterface[]
     */
    public static function makeOrDont($type, $value, $precision = null, $base = 10)
    {

        if (is_numeric($value)) {
            return self::make($type, $value, $precision, $base);
        } elseif (is_object($value)) {
            $reflector = new \ReflectionClass($value);

            if ($value instanceof $type) {
                return $value;
            }

            if ($reflector->implementsInterface(NumberInterface::class)) {
                return self::make($type, $value->getValue(), $precision, $base);
            }
        } elseif (is_array($value)) {
            $newInput = [];
            
            foreach ($value as $key => $item) {
                $newInput[$key] = self::makeOrDont($type, $item, $precision, $base);
            }

            return $newInput;
        }

        throw new \InvalidArgumentException('The $input argument was not numeric or an implementation of NumberInterface.');

    }

    public static function makeFractionFromString($value, $type = self::IMMUTABLE_FRACTION)
    {
        $parts = explode('/', $value);

        if (count($parts) > 2) {
            throw new IntegrityConstraint(
                'Only one division symbol (/) can be used',
                'Change the calling code to not provide more than one division symbol',
                'makeFractionFromString needs either one or zero division symbols in the $value argument; '.$value.' given'
            );
        }

        $numerator = Numbers::make(Numbers::IMMUTABLE, trim(ltrim($parts[0])))->round();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        $denominator = isset($parts[1]) ? Numbers::make(Numbers::IMMUTABLE, trim(ltrim($parts[1])))->round() : Numbers::makeOne();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

        if ($type == self::IMMUTABLE_FRACTION) {
            return new ImmutableFraction($numerator, $denominator);
        } elseif ($type == self::MUTABLE_FRACTION) {
            return new MutableFraction($numerator, $denominator);
        } else {
            throw new IntegrityConstraint(
                'Type must be ImmutableFraction or MutableFraction',
                'Alter to calling code to use the correct type',
                'makeFractionFromString can only make objects of type ImmutableFraction or MutableFraction; '.$type.' given'
            );
        }
    }

    /**
     * @param int|null $precision
     *
     * @return NumberInterface
     */
    public static function makePi($precision = null)

    {
        
        if (!is_null($precision) && ($precision > 105 || $precision < 1)) {
            throw new \InvalidArgumentException('The PI constant cannot have a precision higher than the constant stored (105).');
        }
        
        $pi = self::make(self::IMMUTABLE, self::PI);
        
        if (!is_null($precision)) {
            return $pi->roundToPrecision($precision);
        } else {
            return $pi;
        }
        
    }

    /**
     * @param int|null $precision
     *
     * @return NumberInterface
     */
    public static function makeTau($precision = null)

    {
        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new \InvalidArgumentException('The TAU constant cannot have a precision higher than the constant stored (100).');
        }

        $tau = self::make(self::IMMUTABLE, self::TAU);

        if (!is_null($tau)) {
            return $tau->roundToPrecision($precision);
        } else {
            return $tau;
        }
    }

    /**
     * @param int|null $precision
     *
     * @return NumberInterface
     */
    public static function make2Pi($precision = null)
    {
        return self::makeTau($precision);
    }

    /**
     * @param int|null $precision
     *
     * @return NumberInterface
     */
    public static function makeE($precision = null)

    {

        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new \InvalidArgumentException('The E constant cannot have a precision higher than the constant stored (100).');
        }

        $e = self::make(self::IMMUTABLE, self::E);

        if (!is_null($e)) {
            return $e->roundToPrecision($precision);
        } else {
            return $e;
        }

    }

    /**
     * @param int|null $precision
     *
     * @return NumberInterface
     */
    public static function makeGoldenRatio($precision = null)

    {

        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new \InvalidArgumentException('The Golden Ratio constant cannot have a precision higher than the constant stored (100).');
        }

        $goldenRatio = self::make(self::IMMUTABLE, self::GOLDEN_RATIO);

        if (!is_null($precision)) {
            return $goldenRatio->roundToPrecision($precision);
        } else {
            return $goldenRatio;
        }

    }

    /**
     * @return ImmutableNumber
     */
    public static function makeOne()
    {
        return self::make(self::IMMUTABLE, 1);
    }

    /**
     * @return ImmutableNumber
     */
    public static function makeZero()
    {
        return self::make(self::IMMUTABLE, 0);
    }

}

Push — dev ( a4ab81...299db4 )

Numbers B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

11 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

1		<?php
2
3		namespace Samsara\Fermat;
4
5		use Samsara\Exceptions\UsageError\IntegrityConstraint;
6		use Samsara\Fermat\Values\ImmutableFraction;
7		use Samsara\Fermat\Values\ImmutableNumber;
8		use Samsara\Fermat\Values\MutableFraction;
9		use Samsara\Fermat\Values\MutableNumber;
10		use Samsara\Fermat\Types\Base\NumberInterface;
11
12		class Numbers
13		{
14
15		const MUTABLE = MutableNumber::class;
16		const IMMUTABLE = ImmutableNumber::class;
17		const MUTABLE_FRACTION = MutableFraction::class;
18		const IMMUTABLE_FRACTION = ImmutableFraction::class;
19		/* 105 digits after decimal, which is going to be overkill in almost all places */
20		const PI = '3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148';
21		/* Tau (2pi) to 100 digits */
22		const TAU = '6.283185307179586476925286766559005768394338798750211641949889184615632812572417997256069650684234136';
23		/* Euler's Number to 100 digits */
24		const E = '2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427';
25		/* Golden Ratio to 100 digits */
26		const GOLDEN_RATIO = '1.618033988749894848204586834365638117720309179805762862135448622705260462818902449707207204189391137';
27
28		/**
29		* @param $type
30		* @param $value
31		* @param int\|null $precision
32		* @param int $base
33		* @return ImmutableNumber\|MutableNumber\|ImmutableFraction\|MutableFraction\|NumberInterface
34		*/
35		public static function make($type, $value, $precision = null, $base = 10)
36		{
37
38		if ($type == self::IMMUTABLE) {
39		return new ImmutableNumber(trim($value), $precision, $base);
40		} elseif ($type == self::MUTABLE) {
41		return new MutableNumber(trim($value), $precision, $base);
42		} elseif ($type == self::IMMUTABLE_FRACTION) {
43		return self::makeFractionFromString($value, $type)->convertToBase($base);
44		} elseif ($type == self::MUTABLE_FRACTION) {
45		return self::makeFractionFromString($value, $type)->convertToBase($base);
46		} else {
47		$reflector = new \ReflectionClass($type);
48
49		if ($reflector->implementsInterface(NumberInterface::class)) {
50		/** @var NumberInterface $customNumber */
51		$customNumber = $reflector->newInstance([
52		trim($value),
53		$precision,
54		$base
55		]);
56		return $customNumber;
57		}
58		}
59
60		throw new \InvalidArgumentException('The $type argument was not an implementation of NumberInterface.');
61		}
62
63		/**
64		* @param $type
65		* @param $value
66		* @param int\|null $precision
67		* @param int $base
68		* @return NumberInterface
69		*/
70		public static function makeFromBase10($type, $value, $precision = null, $base = 10)
71		{
72		/**
73		* @var ImmutableNumber\|MutableNumber
74		*/
75		$number = self::make($type, $value, $precision, 10);
76
77		return $number->convertToBase($base);
78		}
79
80		/**
81		* @param $type
82		* @param int\|float\|string\|NumberInterface $value
83		* @param int\|null $precision
84		* @param int $base
85		*
86		*@throws \InvalidArgumentException
87		* @return ImmutableNumber\|MutableNumber\|NumberInterface\|ImmutableNumber[]\|MutableNumber[]\|NumberInterface[]
88		*/
89		public static function makeOrDont($type, $value, $precision = null, $base = 10)
90		{
91
92		if (is_numeric($value)) {
93		return self::make($type, $value, $precision, $base);
94		} elseif (is_object($value)) {
95		$reflector = new \ReflectionClass($value);
96
97		if ($value instanceof $type) {
98		return $value;
99		}
100
101		if ($reflector->implementsInterface(NumberInterface::class)) {
102		return self::make($type, $value->getValue(), $precision, $base);
103		}
104		} elseif (is_array($value)) {
105		$newInput = [];
106
107		foreach ($value as $key => $item) {
108		$newInput[$key] = self::makeOrDont($type, $item, $precision, $base);
109		}
110
111		return $newInput;
112		}
113
114		throw new \InvalidArgumentException('The $input argument was not numeric or an implementation of NumberInterface.');
115
116		}
117
118		public static function makeFractionFromString($value, $type = self::IMMUTABLE_FRACTION)
119		{
120		$parts = explode('/', $value);
121
122		if (count($parts) > 2) {
123		throw new IntegrityConstraint(
124		'Only one division symbol (/) can be used',
125		'Change the calling code to not provide more than one division symbol',
126		'makeFractionFromString needs either one or zero division symbols in the $value argument; '.$value.' given'
127		);
128		}
129
130		$numerator = Numbers::make(Numbers::IMMUTABLE, trim(ltrim($parts[0])))->round();
		0 ignored issues – show Bug introduced 2017-01-09 07:08 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Samsara\Fermat\Types\Base\NumberInterface` as the method `round()` does only exist in the following implementations of said interface: `Samsara\Fermat\Values\ImmutableNumber`, `Samsara\Fermat\Values\MutableNumber`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
131		$denominator = isset($parts[1]) ? Numbers::make(Numbers::IMMUTABLE, trim(ltrim($parts[1])))->round() : Numbers::makeOne();
		0 ignored issues – show Bug introduced 2017-01-09 10:22 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Samsara\Fermat\Types\Base\NumberInterface` as the method `round()` does only exist in the following implementations of said interface: `Samsara\Fermat\Values\ImmutableNumber`, `Samsara\Fermat\Values\MutableNumber`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
132
133		if ($type == self::IMMUTABLE_FRACTION) {
134		return new ImmutableFraction($numerator, $denominator);
135		} elseif ($type == self::MUTABLE_FRACTION) {
136		return new MutableFraction($numerator, $denominator);
137		} else {
138		throw new IntegrityConstraint(
139		'Type must be ImmutableFraction or MutableFraction',
140		'Alter to calling code to use the correct type',
141		'makeFractionFromString can only make objects of type ImmutableFraction or MutableFraction; '.$type.' given'
142		);
143		}
144		}
145
146		/**
147		* @param int\|null $precision
148		*
149		* @return NumberInterface
150		*/
151	View Code Duplication	public static function makePi($precision = null)
		0 ignored issues – show Duplication introduced 2016-11-07 23:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
152		{
153
154		if (!is_null($precision) && ($precision > 105 \|\| $precision < 1)) {
155		throw new \InvalidArgumentException('The PI constant cannot have a precision higher than the constant stored (105).');
156		}
157
158		$pi = self::make(self::IMMUTABLE, self::PI);
159
160		if (!is_null($precision)) {
161		return $pi->roundToPrecision($precision);
162		} else {
163		return $pi;
164		}
165
166		}
167
168		/**
169		* @param int\|null $precision
170		*
171		* @return NumberInterface
172		*/
173	View Code Duplication	public static function makeTau($precision = null)
		0 ignored issues – show Duplication introduced 2016-11-07 23:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
174		{
175		if (!is_null($precision) && ($precision > 100 \|\| $precision < 1)) {
176		throw new \InvalidArgumentException('The TAU constant cannot have a precision higher than the constant stored (100).');
177		}
178
179		$tau = self::make(self::IMMUTABLE, self::TAU);
180
181		if (!is_null($tau)) {
182		return $tau->roundToPrecision($precision);
183		} else {
184		return $tau;
185		}
186		}
187
188		/**
189		* @param int\|null $precision
190		*
191		* @return NumberInterface
192		*/
193		public static function make2Pi($precision = null)
194		{
195		return self::makeTau($precision);
196		}
197
198		/**
199		* @param int\|null $precision
200		*
201		* @return NumberInterface
202		*/
203	View Code Duplication	public static function makeE($precision = null)
		0 ignored issues – show Duplication introduced 2016-11-07 23:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
204		{
205
206		if (!is_null($precision) && ($precision > 100 \|\| $precision < 1)) {
207		throw new \InvalidArgumentException('The E constant cannot have a precision higher than the constant stored (100).');
208		}
209
210		$e = self::make(self::IMMUTABLE, self::E);
211
212		if (!is_null($e)) {
213		return $e->roundToPrecision($precision);
214		} else {
215		return $e;
216		}
217
218		}
219
220		/**
221		* @param int\|null $precision
222		*
223		* @return NumberInterface
224		*/
225	View Code Duplication	public static function makeGoldenRatio($precision = null)
		0 ignored issues – show Duplication introduced 2016-11-07 23:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
226		{
227
228		if (!is_null($precision) && ($precision > 100 \|\| $precision < 1)) {
229		throw new \InvalidArgumentException('The Golden Ratio constant cannot have a precision higher than the constant stored (100).');
230		}
231
232		$goldenRatio = self::make(self::IMMUTABLE, self::GOLDEN_RATIO);
233
234		if (!is_null($precision)) {
235		return $goldenRatio->roundToPrecision($precision);
236		} else {
237		return $goldenRatio;
238		}
239
240		}
241
242		/**
243		* @return ImmutableNumber
244		*/
245		public static function makeOne()
246		{
247		return self::make(self::IMMUTABLE, 1);
248		}
249
250		/**
251		* @return ImmutableNumber
252		*/
253		public static function makeZero()
254		{
255		return self::make(self::IMMUTABLE, 0);
256		}
257
258		}

JordanRL / Fermat

Push — dev ( a4ab81...299db4 )

Numbers B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

11 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like