Stadly\PasswordPolice\Rule\Change

Complexity

Total Complexity

17

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	test()	0	6	1
A	getDate()	0	10	3
A	addConstraint()	0	9	1
A	getViolation()	0	13	4
A	enforce()	0	8	2
A	getMessage()	0	38	5
A	__construct()	0	3	1

<?php

declare(strict_types=1);

namespace Stadly\PasswordPolice\Rule;

use DateInterval;
use DateTimeImmutable;
use DateTimeInterface;
use InvalidArgumentException;
use StableSort\StableSort;
use Stadly\PasswordPolice\Constraint\Date;
use Carbon\CarbonInterval;
use Stadly\Date\Interval;
use Stadly\PasswordPolice\Password;
use Stadly\PasswordPolice\Policy;

final class Change implements RuleInterface
{
    /**
     * @var Date[] Rule constraints.
     */
    private $constraints;

    /**
     * @param DateInterval $min Minimum time since last password change.
     * @param DateInterval|null $max Maximum time since last password change.
     * @param int $weight Constraint weight.
     */
    public function __construct(DateInterval $min, ?DateInterval $max = null, int $weight = 1)
    {
        $this->addConstraint($min, $max, $weight);
    }

    /**
     * @param DateInterval $min Minimum time since last password change.
     * @param DateInterval|null $max Maximum time since last password change.
     * @param int $weight Constraint weight.
     * @return $this
     */
    public function addConstraint(DateInterval $min, ?DateInterval $max = null, int $weight = 1): self
    {
        $this->constraints[] = new Date($min, $max, $weight);

        StableSort::usort($this->constraints, function (Date $a, Date $b): int {
            return $b->getWeight() <=> $a->getWeight();
        });

        return $this;
    }

    /**
     * Check whether a password is in compliance with the rule.
     *
     * @param Password|string $password Password to check.
     * @return bool Whether the password is in compliance with the rule.
     */
    public function test($password): bool
    {
        $date = $this->getDate($password);
        $constraint = $this->getViolation($date);

        return $constraint === null;
    }

    /**
     * Enforce that a password is in compliance with the rule.
     *
     * @param Password|string $password Password that must adhere to the rule.
     * @throws RuleException If the password does not adhrere to the rule.
     */
    public function enforce($password): void
    {
        $date = $this->getDate($password);
        $constraint = $this->getViolation($date);

        if ($constraint !== null) {
            assert($date !== null);
            throw new RuleException($this, $this->getMessage($constraint, $date));
        }
    }

    /**
     * @param DateTimeInterface|null $date When the password was last changed.
     * @return Date|null Constraint violated by the count.
     */
    private function getViolation(?DateTimeInterface $date): ?Date
    {
        if ($date === null) {
            return null;
        }

        foreach ($this->constraints as $constraint) {
            if (!$constraint->test($date)) {
                return $constraint;
            }
        }

        return null;
    }

    /**
     * @param Password|string $password Password to check when was last changed.
     * @return DateTimeInterface|null When the password was last changed.
     */
    private function getDate($password): ?DateTimeInterface
    {
        if ($password instanceof Password) {
            $formerPasswords = $password->getFormerPasswords();

            if ($formerPasswords !== []) {
                return reset($formerPasswords)->getDate();
            }
        }
        return null;
    }

    /**
     * @param Date $constraint Constraint that is violated.
     * @param DateTimeInterface $date Date that violates the constraint.
     * @return string Message explaining the violation.
     */
    private function getMessage(Date $constraint, DateTimeInterface $date): string

The parameter $date is not used and could be removed.

    {
        $translator = Policy::getTranslator();
        $locale = $translator->getLocale();

        $min = CarbonInterval::instance($constraint->getMin());
        $min->locale($locale);
        if ($constraint->getMax() === null) {
            $max = null;
        } else {
            $max = CarbonInterval::instance($constraint->getMax());
            $max->locale($locale);
        }

        if ($constraint->getMax() === null) {
            return $translator->trans(
                'Must be at least %interval% between password changes.',
                ['%interval%' => $min]
            );
        }

        if (0 === Interval::compare(new DateInterval('PT0S'), $min)) {
            return $translator->trans(
                'Must be at most %interval% between password changes.',
                ['%interval%' => $max]
            );
        }

        if (Interval::compare($constraint->getMin(), $constraint->getMax()) === 0) {
            return $translator->trans(
                'Must be exactly %interval% between password changes.',
                ['%interval%' => $min]
            );
        }

        return $translator->trans(
            'Must be between %min% and %max% between password changes.',
            ['%min%' => $min, '%max%' => $max]
        );
    }
}