Stadly\PasswordPolice\Rule\Dictionary

Complexity

Total Complexity

14

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getWordList()	0	3	1
A	__construct()	0	8	1
A	validate()	0	14	2
A	getDictionaryWord()	0	16	4
A	test()	0	9	3
A	getFormattedWords()	0	6	2
A	getMessage()	0	6	1

<?php

declare(strict_types=1);

namespace Stadly\PasswordPolice\Rule;

use RuntimeException;
use Stadly\PasswordPolice\Policy;
use Stadly\PasswordPolice\Rule;
use Stadly\PasswordPolice\ValidationError;
use Stadly\PasswordPolice\WordFormatter;
use Stadly\PasswordPolice\WordList;
use Traversable;

final class Dictionary implements Rule
{
    /**
     * @var WordList Word list for the dictionary.
     */
    private $wordList;

    /**
     * @var WordFormatter[] Word formatters.
     */
    private $wordFormatters;

    /**
     * @var int Constraint weight.
     */
    private $weight;

    /**
     * @param WordList $wordList Word list for the dictionary.
     * @param WordFormatter[] $wordFormatters Word formatters.
     * @param int $weight Constraint weight.
     */
    public function __construct(
        WordList $wordList,
        array $wordFormatters = [],
        int $weight = 1
    ) {
        $this->wordList = $wordList;
        $this->wordFormatters = $wordFormatters;
        $this->weight = $weight;
    }

    /**
     * @return WordList Word list for the dictionary.
     */
    public function getWordList(): WordList
    {
        return $this->wordList;
    }

    /**
     * {@inheritDoc}
     */
    public function test($password, ?int $weight = 1): bool
    {
        if ($weight !== null && $this->weight < $weight) {
            return true;
        }

        $word = $this->getDictionaryWord((string)$password);

        return $word === null;
    }

    /**
     * {@inheritDoc}
     */
    public function validate($password): ?ValidationError
    {
        $word = $this->getDictionaryWord((string)$password);

        if ($word !== null) {
            return new ValidationError(
                $this->getMessage($word),
                $password,
                $this,
                $this->weight
            );
        }

        return null;
    }

    /**
     * @param string $password Password to find dictionary words in.
     * @return string|null Dictionary word in the password.
     * @throws Exception If an error occurred.
     */
    private function getDictionaryWord(string $password): ?string
    {
        foreach ($this->getFormattedWords($password) as $word) {
            try {
                if ($this->wordList->contains($word)) {

It seems like $word can also be of type Traversable; however, parameter $word of Stadly\PasswordPolice\WordList::contains() does only seem to accept string, maybe add an additional type check?

                    return $word;

The expression return $word could return the type Traversable which is incompatible with the type-hinted return null|string. Consider adding an additional type-check to rule them out.

                }
            } catch (RuntimeException $exception) {
                throw new Exception(
                    $this,
                    'An error occurred while using the word list: '.$exception->getMessage(),
                    $exception
                );
            }
        }
        return null;
    }

    /**
     * @param string $word Word to format.
     * @return Traversable<string> Formatted words. May contain duplicates.
     */
    private function getFormattedWords(string $word): Traversable
    {
        yield $word;

        foreach ($this->wordFormatters as $wordFormatter) {
            yield from $wordFormatter->apply([$word]);
        }
    }

    /**
     * @param string $word Word that violates the constraint.
     * @return string Message explaining the violation.
     */
    private function getMessage(string $word): string

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

    {
        $translator = Policy::getTranslator();

        return $translator->trans(
            'Must not contain dictionary words.'
        );
    }
}