PeekAndPoke\Horizons\DateAndTime\LocalDate

Complexity

Total Complexity

57

Size/Duplication

Total Lines	588
Duplicated Lines	8.84 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

98.71%

Importance

Changes	9
Bugs	0	Features	6

43 Methods

Rating	Name	Duplication	Size	Complexity
A	fromTimestamp()	0	4	1
A	now()	0	4	1
A	getDate()	0	4	1
A	getTimestamp()	0	4	1
A	getTimezone()	0	4	1
A	__toString()	0	4	1
A	getOffset()	0	4	1
A	getOffsetInMinutes()	0	6	1
A	getOffsetInHours()	0	6	1
A	format()	0	4	1
A	getClone()	0	4	1
A	getDaylightSavingShift()	0	6	1
A	getStartOfDay()	0	4	1
A	getNearestStartOfDay()	0	8	2
A	getEndOfDay()	0	4	1
A	modifyTime()	0	12	1
A	modifyByMinutes()	0	4	1
A	modifyByHours()	0	4	1
A	modifyByDays()	0	4	1
A	alignToMinutesInterval()	0	15	2
A	getMinutesIntoDay()	0	7	1
A	getHours()	0	4	1
A	getWeekday()	0	4	1
A	min()	0	6	2
A	max()	0	6	2
A	diffInSeconds()	0	6	1
A	diffInMinutes()	0	6	1
A	diffInHours()	0	6	1
A	diffInDays()	0	6	1
A	isBefore()	0	6	1
A	isBeforeOrEqual()	0	6	1
A	isEqual()	0	6	1
A	isAfter()	0	6	1
A	isAfterOrEqual()	0	6	1
A	ensure()	0	8	2
A	raw()	0	11	2
B	__construct()	0	46	5
A	getStartOfPreviousDay()	15	15	2
A	getStartOfNextDay()	15	15	2
A	modifyBySeconds()	0	7	1
A	modifyByInterval()	0	4	1
A	addInterval()	11	11	2
A	subInterval()	11	11	2

<?php
/**
 * File was created 11.03.2015 14:51
 *
 * @author Karsten J. Gerber <kontakt@karsten-gerber.de>
 */
namespace PeekAndPoke\Horizons\DateAndTime;

/**
 * Date
 *
 * @author Karsten J. Gerber <kontakt@karsten-gerber.de>
 */
class LocalDate
{
    /** @var \DateTime */
    private $date;
    /** @var \DateTimeZone */
    private $timezone;

    /**
     * @param int                  $timestamp The unix timestamp
     * @param \DateTimeZone|string $timezone  The timezone or a string the DateTimeZone c'tor can understand
     *
     * @return LocalDate
     */
    public static function fromTimestamp($timestamp, $timezone)
    {
        return new LocalDate($timestamp, $timezone);
    }

    /**
     * @return LocalDate
     */
    public static function now()
    {
        return self::raw(new \DateTime());
    }

    /**
     * @param \DateTime $dateTime
     * @return LocalDate
     */
    public static function raw(\DateTime $dateTime)
    {
        $tz = $dateTime->getTimezone();

        // normalize input coming from Javascript or Java etc...
        if ($tz->getName() === 'Z') {
            $tz = new \DateTimeZone('Etc/UTC');
        }

        return new LocalDate($dateTime, $tz);
    }

    /**
     * @param \DateTime|string|float $input    The date or a string the DateTime c'tor can understand or a timestamp
     * @param \DateTimeZone|string   $timezone The timezone or a string the DateTimeZone c'tor can understand
     */
    public function __construct($input, $timezone)
    {
        if (! $timezone instanceof \DateTimeZone) {
            $timezone = new \DateTimeZone((string) $timezone);
        }

        /////
        // We have to trick PHP a bit here, but why?
        //
        // Apparently things behave different, when setting a timezone like
        // a) 'Europe/Berlin'
        // b) '+02:00'
        //
        // When the date already has a timezone set then
        // a) will only set the timezone
        // b) will set the timezone and will also change the timestamp by 2 hours
        //
        // Therefore we create a fresh date, that does not have a timezone yet, set the timestamp, and then apply the
        // timezone
        //
        // See the unit tests for more as well
        ////
        if ($input instanceof \DateTime) {
            $date = (new \DateTime())
                ->setTimestamp($input->getTimestamp())
                ->setTimezone($timezone);
        } elseif (is_numeric($input)) {
            $date = (new \DateTime())
                ->setTimestamp($input)
                ->setTimezone($timezone);
        } else {
            // when we have string input, we immediately use the timezone
            $date = new \DateTime($input, $timezone);

            // since the given 2nd parameter is ignored for dates like '...+02:00' we check if we need to convert the
            // timezone
            if ($date->getTimezone()->getOffset($date) !== $timezone->getOffset($date)) {
                $date = (new \DateTime())
                    ->setTimestamp($date->getTimestamp())
                    ->setTimezone($timezone);
            }
        }

        $this->date     = $date;
        $this->timezone = $timezone;
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->format();
    }

    /**
     * @return \DateTime
     */
    public function getDate()
    {
        return clone $this->date;
    }

    /**
     * @return int
     */
    public function getTimestamp()
    {
        return $this->date->getTimestamp();
    }

    /**
     * @return \DateTimeZone
     */
    public function getTimezone()
    {
        return clone $this->timezone;
    }


    /**
     * Get the offset of the timezone in seconds
     *
     * @return int
     *
     * @see DateTime::getOffset
     */
    public function getOffset()
    {
        return $this->date->getOffset();
    }

    /**
     * @return float
     */
    public function getOffsetInMinutes()
    {
        $offset = $this->getTimezone()->getOffset($this->getDate());

        return $offset / 60;
    }

    /**
     * @return float
     */
    public function getOffsetInHours()
    {
        $offset = $this->getTimezone()->getOffset($this->getDate());

        return $offset / 3600;
    }

    /**
     * @param string $format
     *
     * @return string
     */
    public function format($format = 'c')
    {
        return $this->date->format($format);
    }

    /**
     * @return LocalDate
     */
    public function getClone()
    {
        return new LocalDate($this->date, $this->timezone);
    }

    /**
     * Get the time saving shift on this date in seconds
     *
     * @return int
     */
    public function getDaylightSavingShift()
    {
        $previousNoon = $this->getStartOfPreviousDay()->modifyByHours(12);

        return  $this->getOffset() - $previousNoon->getOffset();
    }

    /**
     * @return LocalDate
     */
    public function getStartOfDay()
    {
        return $this->modifyTime(0, 0, 0);
    }

    /**
     * Get the nearest start of a day, either the current or the next day depending on the time in the day
     *
     * Every time BEFORE 12:00 will result in the start of that day.
     * Every time AFTER and INCLUDING 12:00 will result in the start of the next day.
     *
     * @return LocalDate
     */
    public function getNearestStartOfDay()
    {
        if ($this->getHours() < 12) {
            return $this->getStartOfDay();
        }

        return $this->getStartOfNextDay();
    }

    /**
     * @return LocalDate
     */
    public function getStartOfPreviousDay()
    {
        $dateCloned = clone $this->getDate();

        // take switches between summer and winter time into account
        if ($dateCloned->format('H') > 21) {
            $dateCloned->modify('-27 hours');
        } else {
            $dateCloned->modify('-24 hours');
        }

        $temp = new LocalDate($dateCloned, $this->timezone);

        return $temp->getStartOfDay();
    }

    /**
     * @return LocalDate
     */
    public function getStartOfNextDay()
    {
        $dateCloned = clone $this->getDate();

        // take switches between summer and winter time into account
        if ($dateCloned->format('H') < 3) {
            $dateCloned->modify('+27 hours');
        } else {
            $dateCloned->modify('+24 hours');
        }

        $temp = new LocalDate($dateCloned, $this->timezone);

        return $temp->getStartOfDay();
    }

    /**
     * @return LocalDate
     */
    public function getEndOfDay()
    {
        return $this->getStartOfDay()->modifyByDays(1);
    }

    /**
     * @param int   $hour
     * @param int   $minute
     * @param int   $second
     *
     * @return LocalDate
     */
    public function modifyTime($hour, $minute, $second)
    {
        $hour   = (int) $hour;
        $minute = (int) $minute;
        $second = (int) $second;

        $clonedDate = clone $this->date;

        $clonedDate->setTime((int) $hour, (int) $minute, (int) $second);

        return new LocalDate($clonedDate, $this->timezone);
    }

    /**
     * @param int $numSeconds
     *
     * @return LocalDate
     */
    public function modifyBySeconds($numSeconds)
    {
        return LocalDate::fromTimestamp(
            $this->getTimestamp() + (int) $numSeconds,
            $this->getTimezone()
        );
    }

    /**
     * @param float $numMinutes
     *
     * @return LocalDate
     */
    public function modifyByMinutes($numMinutes)
    {
        return $this->modifyBySeconds(((double) $numMinutes) * 60);
    }

    /**
     * @param float $numHours
     *
     * @return LocalDate
     */
    public function modifyByHours($numHours)
    {
        return $this->modifyBySeconds(((double) $numHours) * 3600);
    }

    /**
     * @param float $numDays
     *
     * @return LocalDate
     */
    public function modifyByDays($numDays)
    {
        return $this->modifyBySeconds(((double) $numDays) * 86400);
    }

    /**
     * @param \DateInterval|string $interval
     *
     * @deprecated use addInterval or subInterval
     *
     * @return LocalDate
     */
    public function modifyByInterval($interval)
    {
        return $this->addInterval($interval);
    }

    /**
     * @param \DateInterval|string $interval
     *
     * @return LocalDate
     */
    public function addInterval($interval)
    {
        if (!$interval instanceof \DateInterval) {
            $interval = new \DateInterval($interval);
        }

        $dateCloned = clone $this->date;
        $dateCloned->add($interval);

        return new LocalDate($dateCloned, $this->timezone);
    }

    /**
     * @param \DateInterval|string $interval
     *
     * @return LocalDate
     */
    public function subInterval($interval)
    {
        if (!$interval instanceof \DateInterval) {
            $interval = new \DateInterval($interval);
        }

        $dateCloned = clone $this->date;
        $dateCloned->sub($interval);

        return new LocalDate($dateCloned, $this->timezone);
    }

    /**
     * @param $minutesInterval
     *
     * @return LocalDate
     */
    public function alignToMinutesInterval($minutesInterval)
    {
        if ($minutesInterval <= 0) {
            return $this->getClone();
        }

        // This is a work-around for the day-light-saving shift days
        // If we would use minutesIntoDay and then add those to startOfDay, we loose one hour.
        // Example would be '2015-03-29 11:20' with tz 'Europe/Berlin' would result in '2015-03-29 10:00'
        $minutesIntoDay = ((int)$this->date->format('H') * 60) + ((int)$this->date->format('i'));
        // cut off partial intervals
        $corrected = ((int)($minutesIntoDay / $minutesInterval)) * $minutesInterval;

        return $this->getStartOfDay()->modifyByMinutes($corrected);
    }

    /**
     * @return int
     */
    public function getMinutesIntoDay()
    {
        $day  = $this->getStartOfDay();
        $diff = $this->getTimestamp() - $day->getTimestamp();

        return (int) ($diff / 60);
    }

    /**
     * Get the hours portion of the current time
     *
     * @return int
     */
    public function getHours()
    {
        return (int) $this->format('H');
    }

    /**
     * @return int
     */
    public function getWeekday()
    {
        return (int) $this->format('N');
    }

    ////  COMPARISON METHODS  //////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Returns the data that is earlier, either the current or the other
     *
     * @param LocalDate|\DateTime $other
     *
     * @return LocalDate
     */
    public function min($other)
    {
        $other = $this->ensure($other);

        return $this->isBefore($other) ? $this : $other;
    }

    /**
     * Returns the data that is later, either the current or the other
     *
     * @param LocalDate|\DateTime $other
     *
     * @return LocalDate
     */
    public function max($other)
    {
        $other = $this->ensure($other);

        return $this->isAfter($other) ? $this : $other;
    }

    /**
     * Get the number of seconds between this and the other.
     *
     * The result will be negative when this is after the other
     *
     * @param LocalDate|\DateTime $other
     *
     * @return float
     */
    public function diffInSeconds($other)
    {
        $other = $this->ensure($other);

        return ($other->getTimestamp() - $this->getTimestamp());
    }

    /**
     * Get the number of minutes between this and the other.
     *
     * The result will be negative when this is after the other
     *
     * @param LocalDate|\DateTime $other
     *
     * @return float
     */
    public function diffInMinutes($other)
    {
        $other = $this->ensure($other);

        return $this->diffInSeconds($other) / 60;
    }

    /**
     * Get the number of minutes between this and the other.
     *
     * The result will be negative when this is after the other
     *
     * @param LocalDate|\DateTime $other
     *
     * @return float
     */
    public function diffInHours($other)
    {
        $other = $this->ensure($other);

        return $this->diffInSeconds($other) / 3600;
    }

    /**
     * Get the number of minutes between this and the other.
     *
     * The result will be negative when this is after the other
     *
     * @param LocalDate|\DateTime $other
     *
     * @return float
     */
    public function diffInDays($other)
    {
        $other = $this->ensure($other);

        return $this->diffInSeconds($other) / 86400;
    }

    /**
     * @param LocalDate|\DateTime $other
     *
     * @return bool
     */
    public function isBefore($other)
    {
        $other = $this->ensure($other);

        return $this->date < $other->date;
    }

    /**
     * @param LocalDate|\DateTime $other
     *
     * @return bool
     */
    public function isBeforeOrEqual($other)
    {
        $other = $this->ensure($other);

        return $this->date <= $other->date;
    }

    /**
     * @param LocalDate|\DateTime $other
     *
     * @return bool
     */
    public function isEqual($other)
    {
        $other = $this->ensure($other);

        return $this->date->getTimestamp() === $other->date->getTimestamp();
    }

    /**
     * @param LocalDate|\DateTime $other
     *
     * @return bool
     */
    public function isAfter($other)
    {
        $other = $this->ensure($other);

        return $this->date > $other->date;
    }

    /**
     * @param LocalDate|\DateTime $other
     *
     * @return bool
     */
    public function isAfterOrEqual($other)
    {
        $other = $this->ensure($other);

        return $this->date >= $other->date;
    }

    ////  PRIVATE HELPER  //////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * @param mixed $input
     *
     * @return LocalDate
     */
    private function ensure($input)
    {
        if ($input instanceof LocalDate) {
            return $input;
        }

        return new LocalDate($input, $this->timezone);
    }
}