Dictionary::getWholeWordsToCheck() - Code Metrics - Inspection of "Word converters in dictionary" - Stadly/PasswordPolice - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( c6ec0f...bab290 )

by Magnar Ovedal
created 2018-12-05 14:06 UTC
Dictionary::getWholeWordsToCheck() A

↳ Parent: Dictionary
Complexity

Conditions	5
Paths	3
Size

Total Lines	7
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	5
Importance

Changes
Metric	Value
cc	5
eloc	4
nc	3
nop	1
dl	0
loc	7
ccs	5
cts	5
cp	1
crap	5
rs	9.6111
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace Stadly\PasswordPolice\Rule;

use InvalidArgumentException;
use RuntimeException;
use Traversable;
use Stadly\PasswordPolice\Policy;
use Stadly\PasswordPolice\WordConverter\WordConverterInterface;
use Stadly\PasswordPolice\WordList\WordListInterface;

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

    /**
     * @var int Minimum word length to consider.
     */
    private $minWordLength;

    /**
     * @var int|null Maximum word length to consider.
     */
    private $maxWordLength;

    /**
     * @var bool Whether all substrings of the password should be checked.
     */
    private $checkSubstrings;

    /**
     * @var WordConverterInterface[] Word converters.
     */
    private $wordConverters;

    /**
     * @param WordListInterface $wordList Word list for the dictionary.
     * @param int $minWordLength Ignore words shorter than this.
     * @param int|null $maxWordLength Ignore words longer than this.
     * @param bool $checkSubstrings Check all substrings of the password, not just the whole password.
     * @param WordConverterInterface... $wordConverters Word converters.

     */
    public function __construct(
        WordListInterface $wordList,
        int $minWordLength = 3,
        ?int $maxWordLength = 25,
        bool $checkSubstrings = true,
        WordConverterInterface... $wordConverters
    ) {
        if ($minWordLength < 1) {
            throw new InvalidArgumentException('Minimum word length must be positive.');
        }
        if ($maxWordLength !== null && $maxWordLength < $minWordLength) {
            throw new InvalidArgumentException('Maximum word length cannot be smaller than mininum word length.');
        }

        $this->wordList = $wordList;
        $this->minWordLength = $minWordLength;
        $this->maxWordLength = $maxWordLength;
        $this->checkSubstrings = $checkSubstrings;
        $this->wordConverters = $wordConverters;
    }

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

    /**
     * @return int Minimum word length to consider.
     */
    public function getMinWordLength(): int
    {
        return $this->minWordLength;
    }

    /**
     * @return int|null Maximum word length to consider.
     */
    public function getMaxWordLength(): ?int
    {
        return $this->maxWordLength;
    }

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

        return $word === null;
    }

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

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

    /**
     * @param string $password Password to find dictionary words in.
     * @return string|null Dictionary word in the password.
     * @throws TestException If an error occurred while using the word list.
     */
    private function getDictionaryWord(string $password): ?string
    {
        foreach ($this->getWordsToCheck($password) as $word) {
            try {
                if ($this->wordList->contains($word)) {
                if ($this->wordList->contains(/** @scrutinizer ignore-type */ $word)) {
                    return $word;

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

    /**
     * @param string $word Word to check.
     * @return Traversable<string> Variants of the word to check.
     */
    private function getWordsToCheck($word): Traversable
    {
        $convertedWords = $this->getUniqueWords($this->getConvertedWords($word));

        if ($this->checkSubstrings) {
            $wordsToCheck = $this->getUniqueWords($this->getSubstringWordsToCheck($convertedWords));
        } else {
            $wordsToCheck = $this->getWholeWordsToCheck($convertedWords);
        }

        yield from $wordsToCheck;
    }

    /**
     * @param Traversable<string> $words Words to filter.
     * @return Traversable<string> Unique words.
     */
    private function getUniqueWords(Traversable $words): Traversable
    {
        $checked = [];
        foreach ($words as $word) {
            if (isset($checked[$word])) {
                continue;
            }

            $checked[$word] = true;
            yield $word;
        }
    }

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

        foreach ($this->wordConverters as $wordConverter) {
            foreach ($wordConverter->convert($word) as $converted) {
                yield $converted;
            }
        }
    }

    /**
     * @param Traversable<string> $words Words to check.
     * @return Traversable<string> Whole words to check.
     */
    private function getWholeWordsToCheck(Traversable $words): Traversable
    {
        foreach ($words as $word) {
            if ($this->minWordLength <= mb_strlen($word) &&
               ($this->maxWordLength === null || mb_strlen($word) <= $this->maxWordLength)
            ) {
                yield $word;
            }
        }
    }

    /**
     * @param Traversable<string> $words Words to check.
     * @return Traversable<string> Substring words to check.
     */
    private function getSubstringWordsToCheck(Traversable $words): Traversable
    {
        foreach ($words as $word) {
            for ($start = 0; $start < mb_strlen($word); ++$start) {
                $substring = mb_substr($word, $start, $this->maxWordLength);

                for ($wordLength = mb_strlen($substring); $this->minWordLength <= $wordLength; --$wordLength) {
                    yield mb_substr($substring, 0, $wordLength);
                }
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public function getMessage(): string
    {
        $translator = Policy::getTranslator();

        if ($this->checkSubstrings) {
            return $translator->trans(
                'Must not contain dictionary words.'
            );
        } else {
            return $translator->trans(
                'Must not be a dictionary word.'
            );
        }
    }
}

Stadly / PasswordPolice

Push — master ( c6ec0f...bab290 )

Dictionary::getWholeWordsToCheck() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
