ValueObjects\DateTime\Date

Complexity

Total Complexity

16

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Test Coverage

Coverage

95.74%

Importance

Changes	12
Bugs	3	Features	4

11 Methods

Rating	Name	Duplication	Size	Complexity
A	sameValueAs()	0	10	4
A	getYear()	0	4	1
A	getMonth()	0	4	1
A	getDay()	0	4	1
A	fromNative()	0	10	1
A	fromNativeDateTime()	0	8	1
A	now()	0	6	1
A	__construct()	0	13	3
A	toNativeDateTime()	0	12	1
A	jsonSerialize()	0	4	1
A	__toString()	0	4	1

<?php

namespace ValueObjects\DateTime;

use ValueObjects\DateTime\Exception\InvalidDateException;
use ValueObjects\Util\Util;
use ValueObjects\ValueObjectInterface;

class Date implements ValueObjectInterface
{
    /** @var Year */
    protected $year;

    /** @var Month */
    protected $month;

    /** @var MonthDay */
    protected $day;

    /**
     * Returns a new Date from native year, month and day values
     *
     * @param  int    $year

There is no parameter named $year. Was it maybe removed?

     * @param  string $month

There is no parameter named $month. Was it maybe removed?

     * @param  int    $day

There is no parameter named $day. Was it maybe removed?

     * @return Date
     */
    public static function fromNative()
    {
        $args = func_get_args();

        $year  = new Year($args[0]);
        $month = Month::fromNative($args[1]);
        $day   = new MonthDay($args[2]);

        return new static($year, $month, $day);
    }

    /**
     * Returns a new Date from a native PHP \DateTime
     *
     * @param  \DateTime $date
     * @return Date
     */
    public static function fromNativeDateTime(\DateTime $date)
    {
        $year  = \intval($date->format('Y'));
        $month = Month::fromNativeDateTime($date);
        $day   = \intval($date->format('d'));

        return new static(new Year($year), $month, new MonthDay($day));
    }

    /**
     * Returns current Date
     *
     * @return Date
     */
    public static function now()
    {
        $date = new static(Year::now(), Month::now(), MonthDay::now());

        return $date;
    }

    /**
     * Create a new Date
     *
     * @param  Year                 $year
     * @param  Month                $month
     * @param  MonthDay             $day
     * @throws InvalidDateException
     */
    public function __construct(Year $year, Month $month, MonthDay $day)
    {
        \DateTime::createFromFormat('Y-F-j', \sprintf('%d-%s-%d', $year->toNative(), $month, $day->toNative()));
        $nativeDateErrors = \DateTime::getLastErrors();

        if ($nativeDateErrors['warning_count'] > 0 || $nativeDateErrors['error_count'] > 0) {
            throw new InvalidDateException($year->toNative(), $month->toNative(), $day->toNative());
        }

        $this->year  = $year;
        $this->month = $month;
        $this->day   = $day;
    }

    /**
     * Tells whether two Date are equal by comparing their values
     *
     * @param  ValueObjectInterface $date
     * @return bool
     */
    public function sameValueAs(ValueObjectInterface $date)
    {
        if (false === Util::classEquals($this, $date)) {
            return false;
        }

        return $this->getYear()->sameValueAs($date->getYear()) &&

It seems like you code against a concrete implementation and not the interface ValueObjects\ValueObjectInterface as the method getYear() does only exist in the following implementations of said interface: ValueObjects\DateTime\Date.

               $this->getMonth()->sameValueAs($date->getMonth()) &&

It seems like you code against a concrete implementation and not the interface ValueObjects\ValueObjectInterface as the method getMonth() does only exist in the following implementations of said interface: ValueObjects\DateTime\Date.

               $this->getDay()->sameValueAs($date->getDay());

It seems like you code against a concrete implementation and not the interface ValueObjects\ValueObjectInterface as the method getDay() does only exist in the following implementations of said interface: ValueObjects\DateTime\Date.

    }

    /**
     * Get year
     *
     * @return Year
     */
    public function getYear()
    {
        return clone $this->year;
    }

    /**
     * Get month
     *
     * @return Month
     */
    public function getMonth()
    {
        return $this->month;
    }

    /**
     * Get day
     *
     * @return MonthDay
     */
    public function getDay()
    {
        return clone $this->day;
    }

    /**
     * Returns a native PHP \DateTime version of the current Date
     *
     * @return \DateTime
     */
    public function toNativeDateTime()
    {
        $year  = $this->getYear()->toNative();
        $month = $this->getMonth()->getNumericValue();
        $day   = $this->getDay()->toNative();

        $date = new \DateTime();
        $date->setDate($year, $month, $day);
        $date->setTime(0, 0, 0);

        return $date;
    }

    function jsonSerialize()

It is generally recommended to explicitly declare the visibility for methods.

It is recommend to declare an explicit visibility for jsonSerialize.

    {
        return $this->toNativeDateTime();
    }

    /**
     * Returns date as string in format Y-n-j
     *
     * @return string
     */
    public function __toString()
    {
        return $this->toNativeDateTime()->format('Y-n-j');
    }
}