Stadly\PasswordPolice\WordList\Pspell

Complexity

Total Complexity

16

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	fromLocale()	0	22	3
A	contains()	0	22	4
A	getFormattedWords()	0	7	3
A	getUniqueWords()	0	10	3
A	getWordsToCheck()	0	3	1
A	errorHandler()	0	3	1

<?php

declare(strict_types=1);

namespace Stadly\PasswordPolice\WordList;

use ErrorException;
use InvalidArgumentException;
use RuntimeException;
use Stadly\PasswordPolice\WordFormatter;
use Stadly\PasswordPolice\WordList;
use Traversable;

final class Pspell implements WordList
{
    /**
     * @var int Pspell dictionary.
     */
    private $pspell;

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

    /**
     * Pspell dictionaries are case-sensitive.
     * Specify word formatters if tests should also be performed for the word formatted to other cases.
     *
     * @param int $pspell Pspell dictionary link, as generated by `pspell_new` and friends.
     * @param WordFormatter ...$wordFormatters Word formatters.
     */
    public function __construct(int $pspell, WordFormatter ...$wordFormatters)
    {
        $this->pspell = $pspell;
        $this->wordFormatters = $wordFormatters;
    }

    /**
     * Pspell dictionaries are case-sensitive.
     * Specify word formatters if tests should also be performed for the word formatted to other cases.
     *
     * @param string $locale Locale of the pspell dictionary to load. For example `en-US` or `de`.
     * @param WordFormatter ...$wordFormatters Word formatters.
     * @throws RuntimeException If the pspell dictionary could not be loaded.
     * @return self Pspell word list.
     */
    public static function fromLocale(string $locale, WordFormatter ...$wordFormatters): self
    {
        if (preg_match('{^[a-z]{2}(?:[-_][A-Z]{2})?$}', $locale) !== 1) {
            throw new InvalidArgumentException(sprintf('%s is not a valid locale.', $locale));
        }

        set_error_handler([self::class, 'errorHandler']);
        try {
            $pspell = pspell_new($locale);
        } catch (ErrorException $exception) {
            throw new RuntimeException(
                'An error occurred while loading the word list: '.$exception->getMessage(),
                /*code*/0,
                $exception
            );
        } finally {
            restore_error_handler();
        }

        assert($pspell !== false);

        return new self($pspell, ...$wordFormatters);
    }

    /**
     * {@inheritDoc}
     */
    public function contains(string $word): bool
    {
        foreach ($this->getWordsToCheck($word) as $wordVariant) {
            set_error_handler([self::class, 'errorHandler']);
            try {
                $check = pspell_check($this->pspell, $wordVariant);
            } catch (ErrorException $exception) {
                throw new RuntimeException(
                    'An error occurred while using the word list: '.$exception->getMessage(),
                    /*code*/0,
                    $exception
                );
            } finally {
                restore_error_handler();
            }

            if ($check) {
                return true;
            }
        }

        return false;
    }

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

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

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

    /**
     * @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) {
            foreach ($wordFormatter->apply([$word]) as $formatted) {
                yield $formatted;
            }
        }
    }

    /**
     * @throws ErrorException Error converted to an exception.
     */
    private static function errorHandler(int $severity, string $message, string $filename, int $line): void
    {
        throw new ErrorException($message, /*code*/0, $severity, $filename, $line);
    }
}