IntervalComparator - Code Metrics - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

IntervalComparator B
last analyzed 2020-04-15 10:17 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	295
Duplicated Lines	27.8 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

37.74%

Importance

Changes

Metric	Value
wmc	48
lcom	1
cbo	3
dl	82
loc	295
ccs	40
cts	106
cp	0.3774
rs	8.5599
c	0
b	0
f	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	contains()	0	12	4
A	join()	0	8	2
A	union()	0	8	2
A	before()	0	8	2
A	after()	0	8	2
A	equal()	0	8	3
B	intersects()	6	19	7
B	intersection()	22	43	9
B	cover()	22	33	7
B	gap()	32	38	7
A	abuts()	0	7	2

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 IntervalComparator 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 IntervalComparator, and based on these observations, apply Extract Interface, too.

<?php

/**
 * GpsLab component.
 *
 * @author    Peter Gribanov <[email protected]>
 * @copyright Copyright (c) 2016, Peter Gribanov
 * @license   http://opensource.org/licenses/MIT
 */

namespace GpsLab\Component\Interval;

/**
 * The comparator must be used only in intervals for safe use the data types.
 */
class IntervalComparator
{
    /**
     * @var ComparableIntervalInterface
     */
    private $interval;

    /**
     * @param ComparableIntervalInterface $interval
     */
    public function __construct(ComparableIntervalInterface $interval)
    {
        $this->interval = $interval;
    }

    /**
     * Checks if this Interval is equal to the specified interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return bool
     */
    public function equal(ComparableIntervalInterface $interval)
    {
        return
            $this->interval->startPoint()->eq($interval->startPoint()) &&
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->eq($interval->endPoint()) &&
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->type()->equal($interval->type())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ;
    }

    /**
     * Does this interval contain the specified point.
     *
     * @param IntervalPointInterface $point
     *
     * @return bool
     */
    public function contains(IntervalPointInterface $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->startExcluded();
        }

        if ($this->interval->endPoint()->eq($point)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->endExcluded();
        }

        return $this->interval->startPoint()->lt($point) && $this->interval->endPoint()->gt($point);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Does this interval intersect the specified interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return bool
     */
    public function intersects(ComparableIntervalInterface $interval)
    {
        if (
            $this->interval->startPoint()->gt($interval->endPoint()) ||
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->lt($interval->startPoint())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ) {
            return false;
        }

        if ($this->interval->startPoint()->eq($interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->startExcluded() && !$interval->type()->endExcluded();
        }

        if ($this->interval->endPoint()->eq($interval->startPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return !$this->interval->type()->endExcluded() && !$interval->type()->startExcluded();
        }

        return true;
    }

    /**
     * Gets the intersection between this interval and another interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function intersection(ComparableIntervalInterface $interval)
    {
        // intervals is not intersect or impossible create interval from one point
        if (
            $this->interval->startPoint()->gte($interval->endPoint()) ||
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->lte($interval->startPoint())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ) {
            // ignore closed intervals:
            // [a, b] | [b, c] = [b, b]
            return null;
        }

        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return $this->interval
            ->withStart($start)
            ->withEnd($end)
            ->withType(IntervalType::create($type));
    }

    /**
     * Gets the covered interval between this Interval and another interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface
     */
    public function cover(ComparableIntervalInterface $interval)
    {
        $type = IntervalType::TYPE_CLOSED;

        if ($this->interval->startPoint()->lt($interval->startPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $start = $this->interval->startPoint();
            if ($this->interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        } else {
            $start = $interval->startPoint();
            if ($interval->type()->startExcluded()) {
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }
        }

        if ($this->interval->endPoint()->gt($interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $end = $this->interval->endPoint();
            if ($this->interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        } else {
            $end = $interval->endPoint();
            if ($interval->type()->endExcluded()) {
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }
        }

        return $this->interval
            ->withStart($start)
            ->withEnd($end)
            ->withType(IntervalType::create($type));
    }

    /**
     * Gets the gap between this interval and another interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function gap(ComparableIntervalInterface $interval)
    {
        if ($this->interval->startPoint()->gt($interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $type = IntervalType::TYPE_CLOSED;

            if (!$interval->type()->endExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }

            if (!$this->interval->type()->startExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }

            return $this->interval
                ->withStart($interval->endPoint())
                ->withEnd($this->interval->startPoint())
                ->withType(IntervalType::create($type));
        }

        if ($interval->startPoint()->gt($this->interval->endPoint())) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $type = IntervalType::TYPE_CLOSED;

            if (!$this->interval->type()->endExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_START_EXCLUDED;
            }

            if (!$interval->type()->startExcluded()) { // invert exclude
                $type |= IntervalType::TYPE_END_EXCLUDED;
            }

            return $this->interval
                ->withStart($this->interval->endPoint())
                ->withEnd($interval->startPoint())
                ->withType(IntervalType::create($type));
        }

        return null; // no gap
    }

    /**
     * Does this interval abuts with the interval specified.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return bool
     */
    public function abuts(ComparableIntervalInterface $interval)
    {
        return
            $interval->endPoint()->eq($this->interval->startPoint()) ||
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->interval->endPoint()->eq($interval->startPoint())
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ;
    }

    /**
     * Joins the interval between the adjacent.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function join(ComparableIntervalInterface $interval)
    {
        if (!$this->abuts($interval)) {
            return null;
        }

        return $this->cover($interval);
    }

    /**
     * Gets the union between this interval and another interval.
     *
     * @param ComparableIntervalInterface $interval
     *
     * @return ComparableIntervalInterface|null
     */
    public function union(ComparableIntervalInterface $interval)
    {
        if (!$this->intersects($interval)) {
            return null;
        }

        return $this->cover($interval);
    }

    /**
     * The point is before the interval.
     *
     * @param IntervalPointInterface $point
     *
     * @return bool
     */
    public function before(IntervalPointInterface $point)
    {
        if ($this->interval->startPoint()->eq($point)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return $this->interval->type()->startExcluded();
        }

        return $this->interval->startPoint()->gt($point);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * The point is after the interval.
     *
     * @param IntervalPointInterface $point
     *
     * @return bool
     */
    public function after(IntervalPointInterface $point)
    {
        if ($this->interval->endPoint()->eq($point)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return $this->interval->type()->endExcluded();
        }

        return $this->interval->endPoint()->lt($point);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
}


1		<?php
2
3		/**
4		* GpsLab component.
5		*
6		* @author Peter Gribanov <[email protected]>
7		* @copyright Copyright (c) 2016, Peter Gribanov
8		* @license http://opensource.org/licenses/MIT
9		*/
10
11		namespace GpsLab\Component\Interval;
12
13		/**
14		* The comparator must be used only in intervals for safe use the data types.
15		*/
16		class IntervalComparator
17		{
18		/**
19		* @var ComparableIntervalInterface
20		*/
21		private $interval;
22
23		/**
24		* @param ComparableIntervalInterface $interval
25		*/
26	63	public function __construct(ComparableIntervalInterface $interval)
27		{
28	63	$this->interval = $interval;
29	63	}
30
31		/**
32		* Checks if this Interval is equal to the specified interval.
33		*
34		* @param ComparableIntervalInterface $interval
35		*
36		* @return bool
37		*/
38		public function equal(ComparableIntervalInterface $interval)
39		{
40		return

gpslab / interval

IntervalComparator B last analyzed 2020-04-15 10:17 UTC