Spatie\Period\Period

Complexity

Total Complexity

61

Size/Duplication

Total Lines	320
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	make()	0	15	3
B	resolveDate()	0	28	6
A	resolveFormat()	0	15	4
A	getStart()	0	4	1
A	getEnd()	0	4	1
A	length()	0	4	1
A	overlapsWith()	0	12	3
A	touchesWith()	0	12	3
A	startsAfterOrAt()	0	4	1
A	endsAfterOrAt()	0	4	1
A	startsBeforeOrAt()	0	4	1
A	endsBeforeOrAt()	0	4	1
A	startsAfter()	0	4	1
A	endsAfter()	0	4	1
A	startsBefore()	0	4	1
A	endsBefore()	0	4	1
A	contains()	0	12	3
A	equals()	0	12	3
A	gap()	0	22	4
A	overlapSingle()	0	16	4
A	overlap()	0	10	2
A	overlapAll()	0	14	3
B	diffSingle()	0	37	6
A	diff()	0	22	4

<?php

namespace Spatie\Period;

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

class Period
{
    /** @var \DateTimeImmutable */
    protected $start;

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

    public function __construct(DateTimeImmutable $start, DateTimeImmutable $end)
    {
        if ($start > $end) {
            throw InvalidPeriod::endBeforeStart($start, $end);
        }

        $this->start = $start;
        $this->end = $end;
    }

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

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

        return new static(
            self::resolveDate($start, $format),
            self::resolveDate($end, $format)
        );
    }

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

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

        $format = self::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';
    }

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

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

    public function length(): int
    {
        return $this->start->diff($this->end)->days + 1;
    }

    public function overlapsWith(Period $period): bool
    {
        if ($this->start > $period->end) {
            return false;
        }

        if ($period->start > $this->end) {
            return false;
        }

        return true;
    }

    public function touchesWith(Period $period): bool
    {
        if ($this->end->diff($period->start)->days <= 1) {
            return true;
        }

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

        return false;
    }

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

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

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

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

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

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

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

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

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

        if ($date > $this->end) {
            return false;
        }

        return true;
    }

    public function equals(Period $period): bool
    {
        if ($period->start->getTimestamp() !== $this->start->getTimestamp()) {
            return false;
        }

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

        return true;
    }

    public function gap(Period $period): ?Period
    {
        if ($this->overlapsWith($period)) {
            return null;
        }

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

        if ($this->start >= $period->end) {
            return static::make(
                $period->end->add(new DateInterval('P1D')),
                $this->start->sub(new DateInterval('P1D'))

It seems like $this->start->sub(new \DateInterval('P1D')) targeting DateTimeImmutable::sub() can also be of type false; however, Spatie\Period\Period::make() does only seem to accept object<DateTimeInterface>|string, did you maybe forget to handle an error condition?

            );
        }

        return static::make(
            $this->end->add(new DateInterval('P1D')),
            $period->start->sub(new DateInterval('P1D'))

It seems like $period->start->sub(new \DateInterval('P1D')) targeting DateTimeImmutable::sub() can also be of type false; however, Spatie\Period\Period::make() does only seem to accept object<DateTimeInterface>|string, did you maybe forget to handle an error condition?

        );
    }

    public function overlapSingle(Period $period): ?Period
    {
        $start = $this->start > $period->start
            ? $this->start
            : $period->start;

        $end = $this->end < $period->end
            ? $this->end
            : $period->end;

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

        return static::make($start, $end);
    }

    public function overlap(Period ...$periods): PeriodCollection
    {
        $overlapCollection = new PeriodCollection();

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

        return $overlapCollection;
    }

    public function overlapAll(Period ...$periods): Period
    {
        $overlap = clone $this;

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

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

        return $overlap;
    }

    public function diffSingle(Period $period): PeriodCollection
    {
        $periodCollection = new PeriodCollection();

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

            return $periodCollection;
        }

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

        $start = $this->start < $period->start
            ? $this->start
            : $period->start;

        $end = $this->end > $period->end
            ? $this->end
            : $period->end;

        if ($overlap->start > $start) {
            $periodCollection[] = static::make(
                $start,
                $overlap->start->sub(new DateInterval('P1D'))
            );
        }

        if ($overlap->end < $end) {
            $periodCollection[] = static::make(
                $overlap->end->add(new DateInterval('P1D')),
                $end
            );
        }

        return $periodCollection;
    }

    public function diff(Period ...$periods): PeriodCollection
    {
        if (count($periods) === 1) {
            $collection = new PeriodCollection();

            if (! $this->overlapsWith($periods[0])) {
                $collection[] = $this->gap($periods[0]);
            }

            return $collection;
        }

        $diffs = [];

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

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

        return $collection;
    }
}