Numbers - Code Metrics - Inspection of "Finally some testing! And all the series stuff pas..." - JordanRL/Fermat - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 083710...9bd34c )

by Jordan

created 2017-01-14 10:24 UTC

Numbers B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	310
Duplicated Lines	28.39 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

Metric	Value
wmc	48
lcom	1
cbo	6
dl	88
loc	310
rs	8.4864
c	0
b	0
f	0

12 Methods

Rating	Name	Duplication	Size	Complexity
C	make()	0	35	7
A	makeFromBase10()	0	9	1
C	makeOrDont()	0	32	7
B	makeFractionFromString()	0	29	5
B	makePi()	18	18	5
B	makeTau()	16	16	5
A	make2Pi()	0	4	1
B	makeE()	18	18	5
B	makeGoldenRatio()	18	18	5
B	makeNaturalLog10()	18	18	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\Types\Base\DecimalInterface;
use Samsara\Fermat\Types\Base\FractionInterface;
use Samsara\Fermat\Values\Currency;
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;
    const CURRENCY = Currency::class;
    /* 105 digits after decimal, which is going to be overkill in almost all places */
    const PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679';
    /* 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';
    /* Natural log of 10 to 100 digits */
    const LN_10 = '2.302585092994045684017991454684364207601101488628772976033327900967572609677352480235997205089598298';

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

        if (is_object($type)) {
            $type = get_class($type);
        }

        if ($type == static::IMMUTABLE) {
            return new ImmutableNumber(trim($value), $precision, $base);
        } elseif ($type == static::MUTABLE) {
            return new MutableNumber(trim($value), $precision, $base);
        } elseif ($type == static::IMMUTABLE_FRACTION) {
            return self::makeFractionFromString($value, $type)->convertToBase($base);
        } elseif ($type == static::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 IntegrityConstraint(
            '$type must be an implementation of NumberInterface',
            'Provide a type that implements NumberInterface (the Numbers class contains constants for the built in ones)',
            '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);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

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

        if (is_object($value)) {
            $reflector = new \ReflectionClass($value);

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

            if ($reflector->implementsInterface(NumberInterface::class)) {
                return static::make($type, $value->getValue(), $precision, $base);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            }
        } elseif (is_numeric($value)) {
            return static::make($type, $value, $precision, $base);
        } elseif (is_array($value)) {
            $newInput = [];
            
            foreach ($value as $key => $item) {
                $newInput[$key] = static::makeOrDont($type, $item, $precision, $base);
            }

            return $newInput;
        }

        throw new IntegrityConstraint(
            '$input must be an int, float, numeric string, or an implementation of NumberInterface',
            'Provide any of the MANY valid inputs',
            'The $input argument was not numeric or an implementation of NumberInterface.'
        );

    }

    /**
     * @param $value
     * @param $type
     *
     * @return ImmutableFraction|MutableFraction
     * @throws IntegrityConstraint
     */
    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'
            );
        }

        /** @var ImmutableNumber $numerator */
        $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.
    }
}
        /** @var ImmutableNumber $denominator */
        $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
     *
     * @throws IntegrityConstraint
     * @return NumberInterface
     */
    public static function makePi($precision = null)

    {
        
        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new IntegrityConstraint(
                '$precision must be between 1 and 100 inclusive',
                'Provide a precision within range',
                'The PI constant cannot have a precision higher than the constant stored (100)'
            );
        }
        
        if (!is_null($precision)) {
            return self::make(self::IMMUTABLE, self::PI, $precision)->roundToPrecision($precision);
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.
    }
}
        } else {
            return self::make(self::IMMUTABLE, self::PI, 100);
        }
        
    }

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

    {
        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new IntegrityConstraint(
                '$precision must be between 1 and 100 inclusive',
                'Provide a precision within range',
                'The TAU constant cannot have a precision higher than the constant stored (100)'
            );
        }

        if (!is_null($precision)) {
            return self::make(self::IMMUTABLE, self::TAU, $precision)->roundToPrecision($precision);
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.
    }
}
        } else {
            return self::make(self::IMMUTABLE, self::TAU, 100);
        }
    }

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

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

    {

        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new IntegrityConstraint(
                '$precision must be between 1 and 100 inclusive',
                'Provide a precision within range',
                'The E constant cannot have a precision higher than the constant stored (100)'
            );
        }

        if (!is_null($precision)) {
            return self::make(self::IMMUTABLE, self::E, $precision)->roundToPrecision($precision);
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.
    }
}
        } else {
            return self::make(self::IMMUTABLE, self::E, 100);
        }

    }

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

    {

        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new IntegrityConstraint(
                '$precision must be between 1 and 100 inclusive',
                'Provide a precision within range',
                'The Golden Ratio constant cannot have a precision higher than the constant stored (100)'
            );
        }

        if (!is_null($precision)) {
            return self::make(self::IMMUTABLE, self::GOLDEN_RATIO, $precision)->roundToPrecision($precision);
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.
    }
}
        } else {
            return self::make(self::IMMUTABLE, self::GOLDEN_RATIO, 100);
        }

    }

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

    {

        if (!is_null($precision) && ($precision > 100 || $precision < 1)) {
            throw new IntegrityConstraint(
                '$precision must be between 1 and 100 inclusive',
                'Provide a precision within range',
                'The natural log of 10 constant cannot have a precision higher than the constant stored (100)'
            );
        }

        if (!is_null($precision)) {
            return self::make(self::IMMUTABLE, self::LN_10, $precision)->roundToPrecision($precision);
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.
    }
}
        } else {
            return self::make(self::IMMUTABLE, self::LN_10, 100);
        }

    }

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

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

}

Push — dev ( 083710...9bd34c )

Numbers B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

JordanRL / Fermat

Push — dev ( 083710...9bd34c )

Numbers B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like