Spatie\OpeningHours\OpeningHoursForDay

Complexity

Total Complexity

23

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	isOpenAt()	0	10	3
A	fromStrings()	0	14	1
A	nextOpen()	0	14	4
A	findNextOpenInWorkingHours()	0	6	3
A	findNextOpenInFreeTime()	0	13	3
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	count()	0	4	1
A	getIterator()	0	4	1
A	guardAgainstTimeRangeOverlaps()	0	8	3

<?php

namespace Spatie\OpeningHours;

use ArrayAccess;
use ArrayIterator;
use Countable;
use IteratorAggregate;
use Spatie\OpeningHours\Exceptions\OverlappingTimeRanges;
use Spatie\OpeningHours\Helpers\Arr;

class OpeningHoursForDay implements ArrayAccess, Countable, IteratorAggregate
{
    /** @var array */
    protected $openingHours = [];

    public static function fromStrings(array $strings)
    {
        $openingHoursForDay = new static();

        $timeRanges = Arr::map($strings, function ($string) {
            return TimeRange::fromString($string);
        });

        $openingHoursForDay->guardAgainstTimeRangeOverlaps($timeRanges);

        $openingHoursForDay->openingHours = $timeRanges;

        return $openingHoursForDay;
    }

    public function isOpenAt(Time $time)
    {
        foreach ($this->openingHours as $timeRange) {
            if ($timeRange->containsTime($time)) {
                return true;
            }
        }

        return false;
    }

    public function nextOpen(Time $time)
    {
        foreach ($this->openingHours as $timeRange) {
            if ($nextOpen = $this->findNextOpenInWorkingHours($time, $timeRange)) {
                return $nextOpen;
            }

            if ($nextOpen = $this->findNextOpenInFreeTime($time, $timeRange)) {

Are you sure the assignment to $nextOpen is correct as $this->findNextOpenInFreeTime($time, $timeRange) (which targets Spatie\OpeningHours\OpeningHoursForDay::findNextOpenInFreeTime()) seems to always return null.

                return $nextOpen;
            }
        }

        return false;
    }

    private function findNextOpenInWorkingHours(Time $time, TimeRange $timeRange)
    {
        if ($timeRange->containsTime($time) && next($timeRange) !== $timeRange) {
            return next($timeRange);
        }
    }

    private function findNextOpenInFreeTime(Time $time, TimeRange $timeRange, TimeRange &$prevTimeRange = null)
    {
        $timeOffRange = $prevTimeRange ?
            TimeRange::fromString($prevTimeRange->end().'-'.$timeRange->start()) :
            TimeRange::fromString('00:00-'.$timeRange->start())
        ;

        if ($timeOffRange->containsTime($time)) {
            return $timeRange->start();
        }

        $prevTimeRange = $timeRange;
    }

    public function offsetExists($offset): bool
    {
        return isset($this->openingHours[$offset]);
    }

    public function offsetGet($offset)
    {
        return $this->openingHours[$offset];
    }

    public function offsetSet($offset, $value)
    {
        throw new \Exception();
    }

    public function offsetUnset($offset)
    {
        unset($this->openingHours[$offset]);
    }

    public function count(): int
    {
        return count($this->openingHours);
    }

    public function getIterator()
    {
        return new ArrayIterator($this->openingHours);
    }

    protected function guardAgainstTimeRangeOverlaps(array $openingHours)
    {
        foreach (Arr::createUniquePairs($openingHours) as $timeRanges) {
            if ($timeRanges[0]->overlaps($timeRanges[1])) {
                throw OverlappingTimeRanges::forRanges($timeRanges[0], $timeRanges[1]);
            }
        }
    }
}