PhpSpellcheck\Misspelling

Complexity

Total Complexity

18

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Test Coverage

Coverage

96.36%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	1
A	setContext()	0	8	1
A	getSuggestions()	0	3	1
A	getLineNumber()	0	3	1
A	hasSuggestions()	0	3	1
A	getContext()	0	3	1
A	mergeSuggestions()	0	16	3
A	mergeContext()	0	12	3
A	getOffset()	0	3	1
A	getUniqueIdentity()	0	3	1
A	hasContext()	0	3	1
A	canDeterminateUniqueIdentity()	0	4	2
A	getWord()	0	3	1

<?php

declare(strict_types=1);

namespace PhpSpellcheck;

use PhpSpellcheck\Exception\InvalidArgumentException;
use Webmozart\Assert\Assert;

class Misspelling implements MisspellingInterface
{
    /**
     * @var string
     */
    private $word;

    /**
     * @var null|int
     */
    private $offset;

    /**
     * @var null|int
     */
    private $lineNumber;

    /**
     * @var string[]
     */
    private $suggestions;

    /**
     * @var array
     */
    private $context;

    public function __construct(
        string $word,
        ?int $offset = null,
        ?int $lineNumber = null,
        array $suggestions = [],
        array $context = []
    ) {
        Assert::stringNotEmpty($word);

        $this->word = $word;
        $this->offset = $offset;
        $this->lineNumber = $lineNumber;
        $this->suggestions = $suggestions;
        $this->context = $context;
    }

    public function mergeSuggestions(array $suggestionsToAdd): MisspellingInterface
    {
        $mergedSuggestions = [];
        $existingSuggestionsAsKeys = array_flip($this->suggestions);
        foreach ($suggestionsToAdd as $suggestionToAdd) {
            if (!isset($existingSuggestionsAsKeys[$suggestionToAdd])) {
                $this->suggestions[] = $suggestionToAdd;
            }
        }

        return new self(
            $this->word,
            $this->offset,
            $this->lineNumber,
            $mergedSuggestions,
            $this->context
        );
    }

    public function getUniqueIdentity(): string
    {
        return $this->getWord() . $this->getLineNumber() . $this->getOffset();
    }

    public function canDeterminateUniqueIdentity(): bool
    {
        return $this->getLineNumber() !== null
            && $this->getOffset() !== null;
    }

    public function getWord(): string
    {
        return $this->word;
    }

    public function getOffset(): ?int
    {
        return $this->offset;
    }

    public function getLineNumber(): ?int
    {
        return $this->lineNumber;
    }

    public function hasSuggestions(): bool
    {
        return !empty($this->suggestions);
    }

    public function hasContext(): bool
    {
        return !empty($this->context);
    }

    /**
     * @return string[]
     */
    public function getSuggestions(): array
    {
        return $this->suggestions;
    }

    public function getContext(): array
    {
        return $this->context;
    }

    public function setContext(array $context): MisspellingInterface
    {
        return new self(
            $this->word,
            $this->offset,
            $this->lineNumber,
            $this->suggestions,
            $context
        );
    }

    public function mergeContext(array $context, bool $override = true): MisspellingInterface
    {
        if (empty($context)) {
            throw new InvalidArgumentException('Context trying to be merged is empty');
        }

        return new self(
            $this->word,
            $this->offset,
            $this->lineNumber,
            $this->suggestions,
            $override ? array_merge($this->context, $context) : array_merge($context, $this->context)
        );
    }
}