EndlessPeriod::resolveDate() - Code Metrics - Inspection of "add draft for EndlessPeriod" - spatie/period - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#52)

unknown
created 2019-09-29 07:23 UTC
EndlessPeriod::resolveDate() B

↳ Parent: EndlessPeriod
Complexity

Conditions	6
Paths	6
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	28
rs	8.8497
c	0
b	0
f	0
cc	6
nc	6
nop	2
<?php

namespace Spatie\Period;

use DateTime;
use DatePeriod;
use DateInterval;
use DateTimeImmutable;
use DateTimeInterface;
use IteratorAggregate;
use Spatie\Period\Exceptions\InvalidDate;
use Spatie\Period\Exceptions\InvalidPeriod;
use Spatie\Period\Exceptions\CannotComparePeriods;

class EndlessPeriod implements IteratorAggregate, PeriodInterface
{
    /** @var \DateTimeImmutable */
    protected $start;

    /** @var \DateTimeImmutable */
    protected $end;

    /** @var \DateInterval */
    protected $interval;

    /** @var \DateTimeImmutable */
    private $includedStart;

    /** @var \DateTimeImmutable */
    private $includedEnd;

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

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

    public function __construct(
        DateTimeImmutable $start,
        ?DateTimeImmutable $end,
        ?int $precisionMask = null,
        ?int $boundaryExclusionMask = null
    ) {
//        if ($start > $end) {
//            throw InvalidPeriod::endBeforeStart($start, $end);
//        }

        $this->boundaryExclusionMask = $boundaryExclusionMask ?? Boundaries::EXCLUDE_NONE;
        $this->precisionMask = $precisionMask ?? Precision::DAY;

        $this->start = $this->roundDate($start, $this->precisionMask);
        $this->end = null;//$this->roundDate($end, $this->precisionMask);
        $this->interval = $this->createDateInterval($this->precisionMask);

        $this->includedStart = $this->startIncluded()
            ? $this->start
            : $this->start->add($this->interval);

        $this->includedEnd = $this->endIncluded()
            ? $this->end
            : $this->end->sub($this->interval);

    }

    /**
     * @param string|DateTimeInterface $start
     * @param string|DateTimeInterface $end
     * @param int|null $precisionMask
     * @param int|null $boundaryExclusionMask
     * @param string|null $format
     *
     * @return static
     */
    public static function make(
        $start,
        $end = null,
        ?int $precisionMask = null,
        ?int $boundaryExclusionMask = null,
        ?string $format = null
    ): PeriodInterface {
        if ($start === null) {
            throw InvalidDate::cannotBeNull('Start date');
        }

//        if ($end !== null) {
//            throw InvalidDate::shouldBeNull('End date');
//        }

        return new static(
            static::resolveDate($start, $format),
            null,
            $precisionMask,
            $boundaryExclusionMask
        );
    }

    public function startIncluded(): bool
    {
        return ! $this->startExcluded();
    }

    public function startExcluded(): bool
    {
        return Boundaries::EXCLUDE_START & $this->boundaryExclusionMask;
    }

    public function endIncluded(): bool
    {
        return ! $this->endExcluded();
    }

    public function endExcluded(): bool
    {
        return Boundaries::EXCLUDE_END & $this->boundaryExclusionMask;
    }

    public function getStart(): DateTimeImmutable
    {
        return $this->start;
    }

    public function getIncludedStart(): DateTimeImmutable
    {
        return $this->includedStart;
    }

    public function getEnd(): DateTimeImmutable
    {
        return $this->end;
    }

    public function getIncludedEnd(): ?DateTimeImmutable
    {
        return $this->includedEnd;
    }

    public function length(): ?int
    {
        return null;
    }

    public function overlapsWith(PeriodInterface $period): bool
    {
        $this->ensurePrecisionMatches($period);

        if ($this->getIncludedStart() > $period->getIncludedEnd()) {
            return false;
        }

        if ($period->getIncludedStart() > $this->getIncludedEnd()) {
            return false;
        }

        return true;
    }

    public function touchesWith(PeriodInterface $period): bool
    {
        $this->ensurePrecisionMatches($period);

        if ($period instanceof EndlessPeriod) {
            return true;
        }

        if ($this->getIncludedStart()->diff($period->getIncludedEnd())->days <= 1) {
            return true;
        }

        return false;
    }

    public function startsBefore(DateTimeInterface $date): bool
    {
        return $this->getIncludedStart() < $date;
    }

    public function startsBeforeOrAt(DateTimeInterface $date): bool
    {
        return $this->getIncludedStart() <= $date;
    }

    public function startsAfter(DateTimeInterface $date): bool
    {
        return $this->getIncludedStart() > $date;
    }

    public function startsAfterOrAt(DateTimeInterface $date): bool
    {
        return $this->getIncludedStart() >= $date;
    }

    public function startsAt(DateTimeInterface $date): bool
    {
        return $this->getIncludedStart()->getTimestamp() === $this->roundDate(
                $date,
                $this->precisionMask
            )->getTimestamp();
    }

    public function endsBefore(DateTimeInterface $date): bool
    {
        return $this->getIncludedEnd() < $this->roundDate(
                $date,
                $this->precisionMask
            );
    }

    public function endsBeforeOrAt(DateTimeInterface $date): bool
    {
        return $this->getIncludedEnd() <= $this->roundDate(
                $date,
                $this->precisionMask
            );
    }

    public function endsAfter(DateTimeInterface $date): bool
    {
        return $this->getIncludedEnd() > $this->roundDate(
                $date,
                $this->precisionMask
            );
    }

    public function endsAfterOrAt(DateTimeInterface $date): bool
    {
        return $this->getIncludedEnd() >= $this->roundDate(
                $date,
                $this->precisionMask
            );
    }

    public function endsAt(DateTimeInterface $date): bool
    {
        return $this->getIncludedEnd()->getTimestamp() === $this->roundDate(
                $date,
                $this->precisionMask
            )->getTimestamp();
    }

    public function contains(DateTimeInterface $date): bool
    {
        if ($this->roundDate($date, $this->precisionMask) < $this->getIncludedStart()) {
            return false;
        }

        if ($this->roundDate($date, $this->precisionMask) > $this->getIncludedEnd()) {
            return false;
        }

        return true;
    }

    public function equals(PeriodInterface $period): bool
    {
        $this->ensurePrecisionMatches($period);

        if ($period->getIncludedStart()->getTimestamp() !== $this->getIncludedStart()->getTimestamp()) {
            return false;
        }

        if ($period->getIncludedEnd()->getTimestamp() !== $this->getIncludedEnd()->getTimestamp()) {
            return false;
        }

        return true;
    }

    /**
     * @param \Spatie\Period\Period $period
     *
     * @return static|null
     * @throws \Exception
     */
    public function gap(PeriodInterface $period): ?Period
    {
        $this->ensurePrecisionMatches($period);

        if ($this->overlapsWith($period)) {
            return null;
        }

        if ($this->touchesWith($period)) {
            return null;
        }

        if ($this->getIncludedStart() >= $period->getIncludedEnd()) {
            return static::make(
                $period->getIncludedEnd()->add($this->interval),
                $this->getIncludedStart()->sub($this->interval),

                $this->getPrecisionMask()
            );
        }

        return static::make(
            $this->getIncludedEnd()->add($this->interval),
            $period->getIncludedStart()->sub($this->interval),

            $this->getPrecisionMask()
        );
    }

    /**
     * @param \Spatie\Period\Period $period
     *
     * @return static|null
     */
    public function overlapSingle(PeriodInterface $period): ?Period
    {
        $this->ensurePrecisionMatches($period);

        $start = $this->getIncludedStart() > $period->getIncludedStart()
            ? $this->getIncludedStart()
            : $period->getIncludedStart();

        $end = $this->getIncludedEnd() < $period->getIncludedEnd()
            ? $this->getIncludedEnd()
            : $period->getIncludedEnd();

        if ($start > $end) {
            return null;
        }

        return static::make($start, $end, $this->getPrecisionMask());
    }

    /**
     * @param \Spatie\Period\Period ...$periods
     *
     * @return \Spatie\Period\PeriodCollection|static[]
     */
    public function overlap(PeriodInterface ...$periods): PeriodCollection
    {
        $overlapCollection = new PeriodCollection();

        foreach ($periods as $period) {
            $overlap = $this->overlapSingle($period);

            if ($overlap === null) {
                continue;
            }

            $overlapCollection[] = $overlap;
        }

        return $overlapCollection;
    }

    /**
     * @param \Spatie\Period\Period ...$periods
     *
     * @return static
     */
    public function overlapAll(PeriodInterface ...$periods): Period
    {
        $overlap = clone $this;

        if (! count($periods)) {
            return $overlap;
        }

        foreach ($periods as $period) {
            $overlap = $overlap->overlapSingle($period);
        }

        return $overlap;
    }

    public function diffSingle(PeriodInterface $period): PeriodCollection
    {
        $this->ensurePrecisionMatches($period);

        $periodCollection = new PeriodCollection();

        if (! $this->overlapsWith($period)) {
            $periodCollection[] = clone $this;
            $periodCollection[] = clone $period;

            return $periodCollection;
        }

        $overlap = $this->overlapSingle($period);

        $start = $this->getIncludedStart() < $period->getIncludedStart()
            ? $this->getIncludedStart()
            : $period->getIncludedStart();

        $end = $this->getIncludedEnd() > $period->getIncludedEnd()
            ? $this->getIncludedEnd()
            : $period->getIncludedEnd();

        if ($overlap->getIncludedStart() > $start) {
            $periodCollection[] = static::make(
                $start,
                $overlap->getIncludedStart()->sub($this->interval),
                $this->getPrecisionMask()
            );
        }

        if ($overlap->getIncludedEnd() < $end) {
            $periodCollection[] = static::make(
                $overlap->getIncludedEnd()->add($this->interval),
                $end,
                $this->getPrecisionMask()
            );
        }

        return $periodCollection;
    }

    /**
     * @param \Spatie\Period\Period ...$periods
     *
     * @return \Spatie\Period\PeriodCollection|static[]
     */
    public function diff(PeriodInterface ...$periods): PeriodCollection
    {
        if (count($periods) === 1 && ! $this->overlapsWith($periods[0])) {
            $collection = new PeriodCollection();

            $gap = $this->gap($periods[0]);

            if ($gap !== null) {
                $collection[] = $gap;
            }

            return $collection;
        }

        $diffs = [];

        foreach ($periods as $period) {
            $diffs[] = $this->diffSingle($period);
        }

        $collection = (new PeriodCollection($this))->overlap(...$diffs);

        return $collection;
    }

    public function getPrecisionMask(): int
    {
        return $this->precisionMask;
    }

    public function getIterator()
    {
        return new DatePeriod(
            $this->getIncludedStart(),
            $this->interval,
            $this->getIncludedEnd()->add($this->interval)
        );
    }

    protected static function resolveDate($date, ?string $format): DateTimeImmutable
    {
        if ($date instanceof DateTimeImmutable) {
            return $date;
        }

        if ($date instanceof DateTime) {
            return DateTimeImmutable::createFromMutable($date);
        }

        $format = static::resolveFormat($date, $format);

        if (! is_string($date)) {
            throw InvalidDate::forFormat($date, $format);
        }

        $dateTime = DateTimeImmutable::createFromFormat($format, $date);

        if ($dateTime === false) {
            throw InvalidDate::forFormat($date, $format);
        }

        if (strpos($format, ' ') === false) {
            $dateTime = $dateTime->setTime(0, 0, 0);
        }

        return $dateTime;
    }

    protected static function resolveFormat($date, ?string $format): string
    {
        if ($format !== null) {
            return $format;
        }

        if (strpos($format, ' ') === false && strpos($date, ' ') !== false) {
            return 'Y-m-d H:i:s';
        }

        return 'Y-m-d';
    }

    protected function roundDate(DateTimeInterface $date, int $precision): DateTimeImmutable
    {
        [$year, $month, $day, $hour, $minute, $second] = explode(' ', $date->format('Y m d H i s'));
function someFunction() {
    $x = 5;
    echo $x;
}

        $month = (Precision::MONTH & $precision) === Precision::MONTH ? $month : '01';
function someFunction() {
    $x = 5;
    echo $x;
}
        $day = (Precision::DAY & $precision) === Precision::DAY ? $day : '01';
function someFunction() {
    $x = 5;
    echo $x;
}
        $hour = (Precision::HOUR & $precision) === Precision::HOUR ? $hour : '00';
function someFunction() {
    $x = 5;
    echo $x;
}
        $minute = (Precision::MINUTE & $precision) === Precision::MINUTE ? $minute : '00';
function someFunction() {
    $x = 5;
    echo $x;
}
        $second = (Precision::SECOND & $precision) === Precision::SECOND ? $second : '00';
function someFunction() {
    $x = 5;
    echo $x;
}

        return DateTimeImmutable::createFromFormat(
            'Y m d H i s',
            implode(' ', [$year, $month, $day, $hour, $minute, $second])
        );
    }

    protected function createDateInterval(int $precision): DateInterval
    {
        $interval = [
            Precision::SECOND => 'PT1S',
            Precision::MINUTE => 'PT1M',
            Precision::HOUR => 'PT1H',
            Precision::DAY => 'P1D',
            Precision::MONTH => 'P1M',
            Precision::YEAR => 'P1Y',
        ][$precision];

        return new DateInterval($interval);
    }

    protected function ensurePrecisionMatches(PeriodInterface $period): void
    {
        if ($this->precisionMask === $period->precisionMask) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            return;
        }

        throw CannotComparePeriods::precisionDoesNotMatch();
    }
}

GitHub Access Token became invalid

Pull Request — master (#52)

EndlessPeriod::resolveDate() B

Complexity

Size

Duplication

Importance

Available Fixes

1			<?php
2
3			namespace Spatie\Period;
4
5			use DateTime;
6			use DatePeriod;
7			use DateInterval;
8			use DateTimeImmutable;
9			use DateTimeInterface;
10			use IteratorAggregate;
11			use Spatie\Period\Exceptions\InvalidDate;
12			use Spatie\Period\Exceptions\InvalidPeriod;
13			use Spatie\Period\Exceptions\CannotComparePeriods;
14
15			class EndlessPeriod implements IteratorAggregate, PeriodInterface
16			{
17			/** @var \DateTimeImmutable */
18			protected $start;
19
20			/** @var \DateTimeImmutable */
21			protected $end;
22
23			/** @var \DateInterval */
24			protected $interval;
25
26			/** @var \DateTimeImmutable */
27			private $includedStart;
28
29			/** @var \DateTimeImmutable */
30			private $includedEnd;
31
32			/** @var int */
33			private $boundaryExclusionMask;
34
35			/** @var int */
36			private $precisionMask;
37
38			public function __construct(
39			DateTimeImmutable $start,
40			?DateTimeImmutable $end,
spatie / period

GitHub Access Token became invalid

Pull Request — master (#52)

EndlessPeriod::resolveDate() B

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
