Period::createFromDatePeriod() - Code Metrics - Inspection of "adding Period::createFromDatePeriod named construc..." - thephpleague/period - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 0ac86a...c35f79 )

by ignace nyamagana
created 2017-11-26 19:57 UTC
Period::createFromDatePeriod() A

↳ Parent: Period
Complexity

Conditions	2
Paths	2
Size

Total Lines	8
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	2
Importance

Changes
Metric	Value
c	0
b	0
f	0
dl	0
loc	8
ccs	4
cts	4
cp	1
rs	9.4285
cc	2
eloc	4
nc	2
nop	1
crap	2
<?php
/**
 * League.Period (http://period.thephpleague.com)
 *
 * @package   League.period
 * @author    Ignace Nyamagana Butera <[email protected]>
 * @copyright 2014-2015 Ignace Nyamagana Butera
 * @license   https://github.com/thephpleague/period/blob/master/LICENSE (MIT License)
 * @version   4.0.0
 * @link      https://github.com/thephpleague/period/
 */
declare(strict_types=1);

namespace League\Period;

use DateInterval;
use DatePeriod;
use DateTime;
use DateTimeImmutable;
use DateTimeInterface;
use DateTimeZone;
use Generator;
use JsonSerializable;

/**
 * A immutable value object class to manipulate Time Range.
 *
 * @package League.period
 * @author  Ignace Nyamagana Butera <[email protected]>
 * @since   1.0.0
 */
final class Period implements JsonSerializable
{
    /**
     * Period starting included date point.
     *
     * @var DateTimeImmutable
     */
    protected $startDate;

    /**
     * Period ending excluded date point.
     *
     * @var DateTimeImmutable
     */
    protected $endDate;

    /**
     * @inheritdoc
     */
    public static function __set_state(array $period): self
    {
        return new self($period['startDate'], $period['endDate']);
    }

    /**
     * Create a new instance.
     *
     * @param DateTimeInterface|string $startDate starting included date point
     * @param DateTimeInterface|string $endDate   ending excluded date point
     *
     * @throws Exception If $startDate is greater than $endDate
     */
    public function __construct($startDate, $endDate)
    {
        $startDate = static::filterDatePoint($startDate);
        $endDate = static::filterDatePoint($endDate);
        if ($startDate > $endDate) {
            throw new Exception('The ending datepoint must be greater or equal to the starting datepoint');
        }
        $this->startDate = $startDate;
        $this->endDate = $endDate;
    }

    /**
     * Validate the DateTimeInterface.
     *
     * @param DateTimeInterface|string $datepoint
     *
     * @return DateTimeImmutable
     */
    protected static function filterDatePoint($datepoint): DateTimeImmutable
    {
        if ($datepoint instanceof DateTimeImmutable) {
            return $datepoint;
        }

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

        return date_create_immutable($datepoint);
    }

    /**
     * Create a Period object from a starting point and an interval.
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateTimeInterface|string $startDate The start date point
     * @param mixed                    $interval  The interval
     *
     * @return self
     */
    public static function createFromDuration($startDate, $interval): self
    {
        $startDate = static::filterDatePoint($startDate);

        return new self($startDate, $startDate->add(static::filterDateInterval($interval)));
    }

    /**
     * Validate a DateInterval.
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param mixed $interval The interval
     *
     * @return DateInterval
     */
    protected static function filterDateInterval($interval): DateInterval
    {
        if ($interval instanceof DateInterval) {
            return $interval;
        }

        if (false !== ($res = filter_var($interval, FILTER_VALIDATE_INT))) {
            return new DateInterval('PT'.$res.'S');
        }

        return DateInterval::createFromDateString($interval);
    }

    /**
     * Create a Period object from a ending excluded datepoint and an interval.
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateTimeInterface|string $endDate  The start date point
     * @param mixed                    $interval The interval
     *
     * @return self
     */
    public static function createFromDurationBeforeEnd($endDate, $interval): self
    {
        $endDate = static::filterDatePoint($endDate);

        return new self($endDate->sub(static::filterDateInterval($interval)), $endDate);
    }

    /**
     * Create a Period object from a DatePeriod
     *
     * @param DatePeriod $datePeriod
     *
     * @throws Exception If the submitted DatePeriod lacks an End DateTimeInterface
     *
     * @return self
     */
    public static function createFromDatePeriod(DatePeriod $datePeriod): self
    {
        if (null !== ($endDate = $datePeriod->getEndDate())) {
            return new self($datePeriod->getStartDate(), $endDate);
        }

        throw new Exception('The submitted DatePeriod object does not contain an end date');
    }

    /**
     * Create a Period object for a specific Year
     *
     * @param DateTimeInterface|string|int $year
     *
     * @return self
     */
    public static function createFromYear($year): self
    {
        if (is_int($year)) {
            $startDate = date_create_immutable($year.'-01-01');

            return new self($startDate, $startDate->add(new DateInterval('P1Y')));
        }

        $startDate = self::approximateDate('Y-01-01 00:00:00', static::filterDatePoint($year));

        return new self($startDate, $startDate->add(new DateInterval('P1Y')));
    }

    /**
     * Returns a DateTimeInterface object whose value are
     * approximated to the second
     *
     * @param string            $format
     * @param DateTimeInterface $datepoint
     *
     * @return DateTimeInterface
     */
    protected static function approximateDate(string $format, DateTimeInterface $datepoint): DateTimeInterface
    {
        return $datepoint->createFromFormat('Y-m-d H:i:s', $datepoint->format($format), $datepoint->getTimeZone());

    }

    /**
     * Create a Period object for a specific semester in a given year
     *
     * @param DateTimeInterface|string|int $year
     * @param int                          $semester Semester Index from 1 to 2
     *
     * @return self
     */
    public static function createFromSemester($year, int $semester = null): self
    {
        if (1 == func_num_args()) {
            $date = self::filterDatePoint($year);
            $month = (intdiv((int) $date->format('m'), 6) * 6) + 1;
            $startDate = self::approximateDate('Y-m-01 00:00:00', $date->setDate((int) $date->format('Y'), $month, 1));

            return new self($startDate, $startDate->add(new DateInterval('P6M')));
        }

        $month = ((static::validateRange($semester, 1, 2) - 1) * 6) + 1;
        $startDate = date_create_immutable($year.'-'.sprintf("%'.02d", $month).'-01');

        return new self($startDate, $startDate->add(new DateInterval('P6M')));
    }

    /**
     * Validate a int according to a range.
     *
     * @param int $value the value to validate
     * @param int $min   the minimum value
     * @param int $max   the maximal value
     *
     * @throws Exception If the value is not in the range
     *
     * @return int
     */
    protected static function validateRange(int $value, int $min, int $max): int
    {
        $res = filter_var($value, FILTER_VALIDATE_INT, ['options' => ['min_range' => $min, 'max_range' => $max]]);
        if (false !== $res) {
            return $res;
        }

        throw new Exception('the submitted value is not contained within the valid range');
    }

    /**
     * Create a Period object for a specific quarter in a given year
     *
     * @param DateTimeInterface|string|int $year
     * @param int                          $quarter Quarter Index from 1 to 4
     *
     * @return self
     */
    public static function createFromQuarter($year, int $quarter = null): self
    {
        if (1 == func_num_args()) {
            $date = self::filterDatePoint($year);
            $month = (intdiv((int) $date->format('m'), 3) * 3) + 1;
            $startDate = self::approximateDate('Y-m-01 00:00:00', $date->setDate((int) $date->format('Y'), $month, 1));

            return new self($startDate, $startDate->add(new DateInterval('P3M')));
        }

        $month = ((static::validateRange($quarter, 1, 4) - 1) * 3) + 1;
        $startDate = date_create_immutable($year.'-'.sprintf("%'.02d", $month).'-01');

        return new self($startDate, $startDate->add(new DateInterval('P3M')));
    }

    /**
     * Create a Period object for a specific year and month
     *
     * @param DateTimeInterface|string|int $year
     * @param int                          $month Month index from 1 to 12
     *
     * @return self
     */
    public static function createFromMonth($year, int $month = null): self
    {
        if (1 == func_num_args()) {
            $startDate = self::approximateDate('Y-m-01 00:00:00', static::filterDatePoint($year));

            return new self($startDate, $startDate->add(new DateInterval('P1M')));
        }

        $startDate = date_create_immutable($year.'-'.sprintf("%'.02d", self::validateRange($month, 1, 12)).'-01');

        return new self($startDate, $startDate->add(new DateInterval('P1M')));
    }

    /**
     * Create a Period object for a specific week
     *
     * @param DateTimeInterface|string|int $year
     * @param int                          $week index from 1 to 53
     *
     * @return self
     */
    public static function createFromWeek($year, int $week = null): self
    {
        if (1 == func_num_args()) {
            $date = static::filterDatePoint($year);
            $startDate = self::approximateDate(
                'Y-m-d 00:00:00',
                $date->sub(new DateInterval('P'.($date->format('N') - 1).'D'))
            );

            return new self($startDate, $startDate->add(new DateInterval('P1W')));
        }

        $startDate = date_create_immutable()
            ->setISODate($year, self::validateRange($week, 1, 53))
            ->setTime(0, 0, 0)
        ;

        return new self($startDate, $startDate->add(new DateInterval('P1W')));
    }

    /**
     * Create a Period object for a specific date
     *
     * The date is truncated so that the time range starts at midnight
     * according to the date timezone and last a full day.
     *
     * @param DateTimeInterface|string $datepoint
     *
     * @return self
     */
    public static function createFromDay($datepoint): self
    {
        $startDate = self::approximateDate('Y-m-d 00:00:00', static::filterDatePoint($datepoint));

        return new self($startDate, $startDate->add(new DateInterval('P1D')));
    }

    /**
     * Create a Period object for a specific date and hour.
     *
     * The starting datepoint represents the beginning of the hour
     * The Period interval is equal to 1 hour
     *
     * @param DateTimeInterface|string $datepoint
     *
     * @return self
     */
    public static function createFromHour($datepoint): self
    {
        $startDate = self::approximateDate('Y-m-d H:00:00', static::filterDatePoint($datepoint));

        return new self($startDate, $startDate->add(new DateInterval('PT1H')));
    }

    /**
     * Create a Period object for a specific date, hour and minute.
     *
     * The starting datepoint represents the beginning of the minute
     * The Period interval is equal to 1 minute
     *
     * @param DateTimeInterface|string $datepoint
     *
     * @return self
     */
    public static function createFromMinute($datepoint): self
    {
        $startDate = self::approximateDate('Y-m-d H:i:00', static::filterDatePoint($datepoint));

        return new self($startDate, $startDate->add(new DateInterval('PT1M')));
    }

    /**
     * Create a Period object for a specific date, hour, minute and second.
     *
     * The starting datepoint represents the beginning of the second
     * The Period interval is equal to 1 second
     *
     * @param DateTimeInterface|string $datepoint
     *
     * @return self
     */
    public static function createFromSecond($datepoint): self
    {
        $startDate = self::approximateDate('Y-m-d H:i:s', static::filterDatePoint($datepoint));

        return new self($startDate, $startDate->add(new DateInterval('PT1S')));
    }

    /**
     * Returns the Period starting datepoint.
     *
     * The starting datepoint is included in the specified period.
     * The starting datepoint is always less than or equal to the ending datepoint.
     *
     * @return DateTimeImmutable
     */
    public function getStartDate(): DateTimeImmutable
    {
        return $this->startDate;
    }

    /**
     * Returns the Period ending datepoint.
     *
     * The ending datepoint is excluded from the specified period.
     * The ending datepoint is always greater than or equal to the starting datepoint.
     *
     * @return DateTimeImmutable
     */
    public function getEndDate(): DateTimeImmutable
    {
        return $this->endDate;
    }

    /**
     * Returns the Period duration as expressed in seconds
     *
     * @return float
     */
    public function getTimestampInterval(): float
    {
        return $this->endDate->getTimestamp() - $this->startDate->getTimestamp();
    }

    /**
     * Returns the Period duration as a DateInterval object.
     *
     * @return DateInterval
     */
    public function getDateInterval(): DateInterval
    {
        return $this->startDate->diff($this->endDate);
    }

    /**
     * Allows iteration over a set of dates and times,
     * recurring at regular intervals, over the Period object.
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @param int $option can be set to DatePeriod::EXCLUDE_START_DATE
     *                    to exclude the start date from the set of
     *                    recurring dates within the period.
     *
     * @return DatePeriod
     */
    public function getDatePeriod($interval, int $option = 0): DatePeriod
    {
        return new DatePeriod($this->startDate, static::filterDateInterval($interval), $this->endDate, $option);
    }

    /**
     * Allows splitting a Period in smaller Period object according
     * to a given interval.
     *
     * The returned iterable Period set is ordered so that:
     * <ul>
     * <li>The first returned Period MUST share the starting datepoint of the parent object.</li>
     * <li>The last returned Period MUST share the ending datepoint of the parent object.</li>
     * <li>The last returned Period MUST have a duration equal or lesser than the submitted interval.</li>
     * <li>All returned Period except for the first one MUST start immediately after the previously returned Period</li>
     * </ul>
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @return Generator
     */
    public function split($interval): Generator
    {
        $startDate = $this->startDate;
        $interval = static::filterDateInterval($interval);
        do {
            $endDate = $startDate->add($interval);
            if ($endDate > $this->endDate) {
                $endDate = $this->endDate;
            }
            yield new self($startDate, $endDate);

            $startDate = $endDate;
        } while ($startDate < $this->endDate);
    }

    /**
     * Allows splitting a Period in smaller Period object according
     * to a given interval.
     *
     * The returned iterable Period set is ordered so that:
     * <ul>
     * <li>The first returned Period MUST share the ending datepoint of the parent object.</li>
     * <li>The last returned Period MUST share the starting datepoint of the parent object.</li>
     * <li>The last returned Period MUST have a duration equal or lesser than the submitted interval.</li>
     * <li>All returned Period except for the first one MUST end immediately before the previously returned Period</li>
     * </ul>
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @return Generator
     */
    public function splitBackwards($interval): Generator
    {
        $endDate = $this->endDate;
        $interval = static::filterDateInterval($interval);
        do {
            $startDate = $endDate->sub($interval);
            if ($startDate < $this->startDate) {
                $startDate = $this->startDate;
            }
            yield new self($startDate, $endDate);

            $endDate = $startDate;
        } while ($endDate > $this->startDate);
    }

    /**
     * Returns the string representation of a Period object
     * as a string in the ISO8601 interval format
     *
     * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
     *
     * @return string
     */
    public function __toString()
    {
        $period = $this->jsonSerialize();

        return $period['startDate'].'/'.$period['endDate'];
    }

    /**
     * Returns the Json representation of a Period object using
     * the JSON representation of dates as returned by Javascript Date.toJSON() method
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toJSON
     *
     * @return string[]
     */
    public function jsonSerialize()
    {
        static $iso8601_format = 'Y-m-d\TH:i:s.u\Z';
        static $utc;
        $utc = $utc ?? new DateTimeZone('UTC');

        return [
            'startDate' => $this->startDate->setTimeZone($utc)->format($iso8601_format),
            'endDate' => $this->endDate->setTimeZone($utc)->format($iso8601_format),
        ];
    }

    /**
     * Compares two Period objects according to their duration.
     *
     * Returns:
     * <ul>
     * <li> -1 if the current Period duration is lesser than the submitted Period duration
     * <li> 1 if the current Period duration is greater than the submitted Period duration
     * <li> 0 if both Period have the same duration
     * </ul>
     *
     * @param Period $period
     *
     * @return int
     */
    public function compareDuration(Period $period): int
    {
        return $this->endDate <=> $this->startDate->add($period->getDateInterval());
    }

    /**
     * Tells whether the current Period object duration
     * is greater than the submitted one.
     *
     * @param Period $period
     *
     * @return bool
     */
    public function durationGreaterThan(Period $period): bool
    {
        return 1 == $this->compareDuration($period);
    }

    /**
     * Tells whether the current Period object duration
     * is less than the submitted one.
     *
     * @param Period $period
     *
     * @return bool
     */
    public function durationLessThan(Period $period): bool
    {
        return -1 == $this->compareDuration($period);
    }

    /**
     * Tells whether the current Period object duration
     * is equal to the submitted one
     *
     * @param Period $period
     *
     * @return bool
     */
    public function sameDurationAs(Period $period): bool
    {
        return 0 == $this->compareDuration($period);
    }

    /**
     * Tells whether two Period share the same datepoints.
     *
     * @param Period $period
     *
     * @return bool
     */
    public function sameValueAs(Period $period): bool
    {
        return $this->startDate == $period->getStartDate()
            && $this->endDate == $period->getEndDate();
    }

    /**
     * Tells whether two Period object abuts
     *
     * @param Period $period
     *
     * @return bool
     */
    public function abuts(Period $period): bool
    {
        return $this->startDate == $period->getEndDate()
            || $this->endDate == $period->getStartDate();
    }

    /**
     * Tells whether two Period objects overlaps
     *
     * @param Period $period
     *
     * @return bool
     */
    public function overlaps(Period $period): bool
    {
        return !$this->abuts($period)
            && $this->startDate < $period->getEndDate()
            && $this->endDate > $period->getStartDate();
    }

    /**
     * Tells whether a Period is entirely after the specified index
     *
     * The specified index can be
     * <ul>
     * <li>a Period</li>
     * <li>a DateTimeInterface</li>
     * <li>a string in a format supported by DateTimeImmutable::__construct</li>
     * </ul>
     *
     * @param Period|DateTimeInterface|string $index
     *
     * @return bool
     */
    public function isAfter($index): bool
    {
        if ($index instanceof Period) {
            return $this->startDate >= $index->getEndDate();
        }

        return $this->startDate > static::filterDatePoint($index);
    }

    /**
     * Tells whether a Period is entirely before the specified index
     *
     * The specified index can be
     * <ul>
     * <li>a Period</li>
     * <li>a DateTimeInterface</li>
     * <li>a string in a format supported by DateTimeImmutable::__construct</li>
     * </ul>
     *
     * @param Period|DateTimeInterface|string $index
     *
     * @return bool
     */
    public function isBefore($index): bool
    {
        if ($index instanceof Period) {
            return $this->endDate <= $index->getStartDate();
        }

        return $this->endDate <= static::filterDatePoint($index);
    }

    /**
     * Tells whether the specified index is fully contained within
     * the current Period object.
     *
     * The specified index can be
     * <ul>
     * <li>a Period</li>
     * <li>a DateTimeInterface</li>
     * <li>a string in a format supported by DateTimeImmutable::__construct</li>
     * </ul>
     *
     * @param Period|DateTimeInterface|string $index
     *
     * @return bool
     */
    public function contains($index): bool
    {
        if ($index instanceof Period) {
            return $this->containsPeriod($index);
        }

        return $this->containsDatePoint($index);
    }

    /**
     * Tells whether a Period object is fully contained within
     * the current Period object.
     *
     * @param Period $period
     *
     * @return bool
     */
    protected function containsPeriod(Period $period): bool
    {
        return $this->contains($period->getStartDate())
            && ($period->getEndDate() >= $this->startDate && $period->getEndDate() <= $this->endDate);
    }

    /**
     * Tells whether a datepoint is fully contained within
     * the current Period object.
     *
     * @param DateTimeInterface|string $datepoint
     *
     * @return bool
     */
    protected function containsDatePoint($datepoint): bool
    {
        $datetime = static::filterDatePoint($datepoint);

        return ($datetime >= $this->startDate && $datetime < $this->endDate)
            || ($datetime == $this->startDate && $datetime == $this->endDate);
    }

    /**
     * Returns a new Period object with a new included starting date point.
     *
     * @param DateTimeInterface|string $startDate date point
     *
     * @return self
     */
    public function startingOn($startDate): self
    {
        return new self(static::filterDatePoint($startDate), $this->endDate);
    }

    /**
     * Returns a new Period object with a new ending date point.
     *
     * @param DateTimeInterface|string $endDate date point
     *
     * @return self
     */
    public function endingOn($endDate): self
    {
        return new self($this->startDate, static::filterDatePoint($endDate));
    }

    /**
     * Returns a new Period object with a new ending date point.
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @return self
     */
    public function withDuration($interval): self
    {
        return new self($this->startDate, $this->startDate->add(static::filterDateInterval($interval)));
    }

    /**
     * Returns a new Period object with a new starting date point.
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @return self
     */
    public function withDurationBeforeEnd($interval): self
    {
        return new self($this->endDate->sub(static::filterDateInterval($interval)), $this->endDate);
    }

    /**
     * Returns a new Period object with a new starting date point
     * moved forward or backward by the given interval
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @return self
     */
    public function moveStartDate($interval): self
    {
        return new self($this->startDate->add(static::filterDateInterval($interval)), $this->endDate);
    }

    /**
     * Returns a new Period object with a new ending date point
     * moved forward or backward by the given interval
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @return self
     */
    public function moveEndDate($interval): self
    {
        return new self($this->startDate, $this->endDate->add(static::filterDateInterval($interval)));
    }

    /**
     * Returns a new Period object where the datepoints
     * are moved forwards or backward simultaneously by the given DateInterval
     *
     * The interval can be
     * <ul>
     * <li>a DateInterval object</li>
     * <li>an int interpreted as the duration expressed in seconds.</li>
     * <li>a string in a format supported by DateInterval::createFromDateString</li>
     * </ul>
     *
     * @param DateInterval|int|string $interval The interval
     *
     * @return self
     */
    public function move($interval): self
    {
        $interval = static::filterDateInterval($interval);

        return new self($this->startDate->add($interval), $this->endDate->add($interval));
    }

    /**
     * Merges one or more Period objects to return a new Period object.
     *
     * The resultant object represents the largest duration possible.
     *
     * @param Period... $periods one or more Period objects

     *
     * @return self
     */
    public function merge(Period ...$periods): self
    {
        return array_reduce($periods, [$this, 'reducer'], $this);
    }

    /**

     * Returns a Period whose endpoints are the larget possible
     * between 2 instance of Period objects
     *
     * @param Period $carry
     * @param Period $period
     *
     * @return self
     */
    protected function reducer(Period $carry, Period $period): self
    {
        if ($carry->getStartDate() > $period->getStartDate()) {
            $carry = $carry->startingOn($period->getStartDate());
        }

        if ($carry->getEndDate() < $period->getEndDate()) {
            $carry = $carry->endingOn($period->getEndDate());
        }

        return $carry;
    }

    /**
     * Computes the intersection between two Period objects.
     *
     * @param Period $period
     *
     * @throws Exception If Both objects do not overlaps
     *
     * @return self
     */
    public function intersect(Period $period): self
    {
        if (!$this->overlaps($period)) {
            throw new Exception('Both object should at least overlaps');
        }

        return new self(
            ($period->getStartDate() > $this->startDate) ? $period->getStartDate() : $this->startDate,
            ($period->getEndDate() < $this->endDate) ? $period->getEndDate() : $this->endDate
        );
    }

    /**
     * Computes the gap between two Period objects.
     *
     * @param Period $period
     *
     * @return self
     */
    public function gap(Period $period): self
    {
        if ($period->getStartDate() > $this->startDate) {
            return new self($this->endDate, $period->getStartDate());
        }

        return new self($period->getEndDate(), $this->startDate);
    }

    /**
     * Returns the difference between two Period objects expressed in seconds
     *
     * @param Period $period
     *
     * @return float
     */
    public function timestampIntervalDiff(Period $period): float
    {
        return $this->getTimestampInterval() - $period->getTimestampInterval();
    }

    /**
     * Returns the difference between two Period objects expressed in DateInterval
     *
     * @param Period $period
     *
     * @return DateInterval
     */
    public function dateIntervalDiff(Period $period): DateInterval
    {
        return $this->endDate->diff($this->startDate->add($period->getDateInterval()));
    }

    /**
     * Computes the difference between two overlapsing Period objects
     *
     * Returns an array containing the difference expressed as Period objects
     * The array will:
     *
     * <ul>
     * <li>be empty if both objects have the same datepoints</li>
     * <li>contain one Period object if both objects share one datepoint</li>
     * <li>contain two Period objects if both objects share no datepoint</li>
     * </ul>
     *
     * @param Period $period
     *
     * @throws Exception if both object do not overlaps
     *
     * @return Period[]
     */
    public function diff(Period $period): array
    {
        if (!$this->overlaps($period)) {
            throw new Exception('Both Period objects must overlaps');
        }

        $res = [
            static::createFromDatepoints($this->startDate, $period->getStartDate()),
            static::createFromDatepoints($this->endDate, $period->getEndDate()),
        ];

        $filter = function (Period $period) {
            return $period->getStartDate() != $period->getEndDate();
        };

        return array_values(array_filter($res, $filter));
    }

    /**
     * Create a new instance given two datepoints
     *
     * The datepoints will be used as to allow the creation of
     * a Period object
     *
     * @param DateTimeInterface|string $datePoint1 datepoint
     * @param DateTimeInterface|string $datePoint2 datepoint
     *
     * @return Period
     */
    protected static function createFromDatepoints($datePoint1, $datePoint2): self
    {
        $startDate = static::filterDatePoint($datePoint1);
        $endDate = static::filterDatePoint($datePoint2);
        if ($startDate > $endDate) {
            return new self($endDate, $startDate);
        }

        return new self($startDate, $endDate);
    }
}

thephpleague / period

Push — master ( 0ac86a...c35f79 )

Period::createFromDatePeriod() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
