OpeningHoursForDay::isOpenAtNight() - Code Metrics - Inspection of "Merge pull request #112 from kylekatarnls/feature/..." - spatie/opening-hours - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e31ec7...148746 )

by Kyle

created 2019-06-04 15:54 UTC

OpeningHoursForDay::isOpenAtNight() A

↳ Parent: OpeningHoursForDay

Complexity

Conditions	4
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0
cc	4
nc	3
nop	1

<?php

namespace Spatie\OpeningHours;

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

class OpeningHoursForDay implements ArrayAccess, Countable, IteratorAggregate
{
    use DataTrait;

    /** @var \Spatie\OpeningHours\TimeRange[] */
    protected $openingHours = [];

    public static function fromStrings(array $strings)
    {
        if (isset($strings['hours'])) {
            return static::fromStrings($strings['hours'])->setData($strings['data'] ?? null);
        }

        $openingHoursForDay = new static();

        if (isset($strings['data'])) {
            $openingHoursForDay->setData($strings['data'] ?? null);
            unset($strings['data']);
        }

        $timeRanges = Arr::map($strings, function ($string) {
            return TimeRange::fromDefinition($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 isOpenAtNight(Time $time)
    {
        foreach ($this->openingHours as $timeRange) {
            if ($timeRange->overflowsNextDay() && TimeRange::fromMidnight($timeRange->end())->containsTime($time)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param callable[] $filters
     *
     * @return Time|bool
     */
    public function openingHoursFilter(array $filters)
    {
        foreach ($this->openingHours as $timeRange) {
            foreach ($filters as $filter) {
                if ($result = $filter($timeRange)) {
                    reset($timeRange);

                    return $result;
                }
            }
        }

        return false;
    }

    /**
     * @param Time $time
     *
     * @return bool|Time
     */
    public function nextOpen(Time $time)
    {
        return $this->openingHoursFilter([
            function ($timeRange) use ($time) {
                return $this->findNextOpenInFreeTime($time, $timeRange);
            },
        ]);
    }

    /**
     * @param Time $time
     *
     * @return bool|Time
     */
    public function nextClose(Time $time)
    {
        return $this->openingHoursFilter([
            function ($timeRange) use ($time) {
                return $this->findNextCloseInWorkingHours($time, $timeRange);
            },
            function ($timeRange) use ($time) {
                return $this->findNextCloseInFreeTime($time, $timeRange);
            },
        ]);
    }

    protected function findNextOpenInFreeTime(Time $time, TimeRange $timeRange)
    {
        if (TimeRange::fromString('00:00-'.$timeRange->start())->containsTime($time)) {
            return $timeRange->start();
        }
    }

    protected function findNextCloseInWorkingHours(Time $time, TimeRange $timeRange)
    {
        if ($timeRange->containsTime($time)) {
            return next($timeRange);
        }
    }

    protected function findNextCloseInFreeTime(Time $time, TimeRange $timeRange)
    {
        if (TimeRange::fromString('00:00-'.$timeRange->start())->containsTime($time)) {
            return $timeRange->end();
        }
    }

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

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

    public function offsetSet($offset, $value)
    {
        throw NonMutableOffsets::forClass(static::class);
    }

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

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

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

    public function isEmpty(): bool
    {
        return empty($this->openingHours);
    }

    public function map(callable $callback): array
    {
        return Arr::map($this->openingHours, $callback);
    }

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

    public function __toString()
    {
        $values = [];
        foreach ($this->openingHours as $openingHour) {
            $values[] = (string) $openingHour;
        }

        return implode(',', $values);
    }
}


1			<?php
2
3			namespace Spatie\OpeningHours;
4
5			use Countable;
6			use ArrayAccess;
7			use ArrayIterator;
8			use IteratorAggregate;
9			use Spatie\OpeningHours\Helpers\Arr;
10			use Spatie\OpeningHours\Helpers\DataTrait;
11			use Spatie\OpeningHours\Exceptions\NonMutableOffsets;
12			use Spatie\OpeningHours\Exceptions\OverlappingTimeRanges;
13
14			class OpeningHoursForDay implements ArrayAccess, Countable, IteratorAggregate
15			{
16			use DataTrait;
17
18			/** @var \Spatie\OpeningHours\TimeRange[] */
19			protected $openingHours = [];
20
21			public static function fromStrings(array $strings)
22			{
23			if (isset($strings['hours'])) {
24			return static::fromStrings($strings['hours'])->setData($strings['data'] ?? null);
25			}
26
27			$openingHoursForDay = new static();
28
29			if (isset($strings['data'])) {
30			$openingHoursForDay->setData($strings['data'] ?? null);
31			unset($strings['data']);
32			}
33
34			$timeRanges = Arr::map($strings, function ($string) {
35			return TimeRange::fromDefinition($string);
36			});
37
38			$openingHoursForDay->guardAgainstTimeRangeOverlaps($timeRanges);
39
40			$openingHoursForDay->openingHours = $timeRanges;
41
42			return $openingHoursForDay;
43			}
44
45			public function isOpenAt(Time $time)
46			{
47			foreach ($this->openingHours as $timeRange) {
48			if ($timeRange->containsTime($time)) {
49			return true;
50			}
51			}
52
53			return false;
54			}
55
56			public function isOpenAtNight(Time $time)
57			{
58			foreach ($this->openingHours as $timeRange) {
59			if ($timeRange->overflowsNextDay() && TimeRange::fromMidnight($timeRange->end())->containsTime($time)) {
60			return true;
61			}
62			}
63
64			return false;
65			}
66
67			/**
68			* @param callable[] $filters
69			*
70			* @return Time\|bool
71			*/
72			public function openingHoursFilter(array $filters)
73			{
74			foreach ($this->openingHours as $timeRange) {
75			foreach ($filters as $filter) {
76			if ($result = $filter($timeRange)) {
77			reset($timeRange);
78
79			return $result;
80			}
81			}
82			}
83
84			return false;
85			}
86
87			/**
88			* @param Time $time
89			*
90			* @return bool\|Time
91			*/
92			public function nextOpen(Time $time)
93			{
94			return $this->openingHoursFilter([
95			function ($timeRange) use ($time) {
96			return $this->findNextOpenInFreeTime($time, $timeRange);
97			},
98			]);
99			}
100
101			/**
102			* @param Time $time
103			*
104			* @return bool\|Time
105			*/
106			public function nextClose(Time $time)
107			{
108			return $this->openingHoursFilter([
109			function ($timeRange) use ($time) {
110			return $this->findNextCloseInWorkingHours($time, $timeRange);
111			},
112			function ($timeRange) use ($time) {
113			return $this->findNextCloseInFreeTime($time, $timeRange);
114			},
115			]);
116			}
117
118			protected function findNextOpenInFreeTime(Time $time, TimeRange $timeRange)
119			{
120			if (TimeRange::fromString('00:00-'.$timeRange->start())->containsTime($time)) {
121			return $timeRange->start();
122			}
123			}
124
125			protected function findNextCloseInWorkingHours(Time $time, TimeRange $timeRange)
126			{
127			if ($timeRange->containsTime($time)) {
128			return next($timeRange);
129			}
130			}
131
132			protected function findNextCloseInFreeTime(Time $time, TimeRange $timeRange)
133			{
134			if (TimeRange::fromString('00:00-'.$timeRange->start())->containsTime($time)) {
135			return $timeRange->end();
136			}
137			}
138
139			public function offsetExists($offset): bool
140			{
141			return isset($this->openingHours[$offset]);
142			}
143
144			public function offsetGet($offset)
145			{
146			return $this->openingHours[$offset];
147			}
148
149			public function offsetSet($offset, $value)
150			{
151			throw NonMutableOffsets::forClass(static::class);
152			}
153
154			public function offsetUnset($offset)
155			{
156			unset($this->openingHours[$offset]);
157			}
158
159			public function count(): int
160			{
161			return count($this->openingHours);
162			}
163
164			public function getIterator()
165			{
166			return new ArrayIterator($this->openingHours);
167			}
168
169			public function isEmpty(): bool
170			{
171			return empty($this->openingHours);
172			}
173
174			public function map(callable $callback): array
175			{
176			return Arr::map($this->openingHours, $callback);
177			}
178
179			protected function guardAgainstTimeRangeOverlaps(array $openingHours)
180			{
181			foreach (Arr::createUniquePairs($openingHours) as $timeRanges) {
182			if ($timeRanges[0]->overlaps($timeRanges[1])) {
183			throw OverlappingTimeRanges::forRanges($timeRanges[0], $timeRanges[1]);
184			}
185			}
186			}
187
188			public function __toString()
189			{
190			$values = [];
191			foreach ($this->openingHours as $openingHour) {
192			$values[] = (string) $openingHour;
193			}
194
195			return implode(',', $values);
196			}
197			}
198

spatie / opening-hours

GitHub Access Token became invalid

Push — master ( e31ec7...148746 )

OpeningHoursForDay::isOpenAtNight() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like