App\Model\Blame

Complexity

Total Complexity

23

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	prepareData()	0	27	6
A	getQuery()	0	3	1
A	getTokenizedQuery()	0	3	1
A	getFirstQueryToken()	0	3	1
A	__construct()	0	8	1
A	getMatches()	0	3	1
B	searchTokens()	0	50	8
A	getAsOf()	0	11	3
A	getEdits()	0	3	1

<?php

declare(strict_types = 1);

namespace App\Model;

use App\Repository\BlameRepository;

/**
 * A Blame will search the given page for the given text and return the relevant revisions and authors.
 */
class Blame extends Authorship
{
    /** @var string Text to search for. */
    protected string $query;

    /** @var array|null Matches, keyed by revision ID, each with keys 'edit' <Edit> and 'tokens' <string[]>. */
    protected ?array $matches;

    /** @var Edit|null Target revision that is being blamed. */
    protected ?Edit $asOf;

    /**
     * Blame constructor.
     * @param BlameRepository $repository
     * @param Page $page The page to process.
     * @param string $query Text to search for.
     * @param string|null $target Either a revision ID or date in YYYY-MM-DD format. Null to use latest revision.
     */
    public function __construct(
        BlameRepository $repository,
        Page $page,
        string $query,
        ?string $target = null
    ) {
        parent::__construct($repository, $page, $target);
        $this->query = $query;
    }

    /**
     * Get the search query.
     * @return string
     */
    public function getQuery(): string
    {
        return $this->query;
    }

    /**
     * Matches, keyed by revision ID, each with keys 'edit' <Edit> and 'tokens' <string[]>.
     * @return array|null
     */
    public function getMatches(): ?array
    {
        return $this->matches;
    }

    /**
     * Get all the matches as Edits.
     * @return Edit[]|null
     */
    public function getEdits(): ?array
    {
        return array_column($this->matches, 'edit');

It seems like $this->matches can also be of type null; however, parameter $array of array_column() does only seem to accept array, maybe add an additional type check?

    }

    /**
     * Strip out spaces, since they are not accounted for in the WikiWho API.
     * @return string
     */
    public function getTokenizedQuery(): string
    {
        return strtolower(preg_replace('/\s*/m', '', $this->query));
    }

    /**
     * Get the first "token" of the search query. A "token" in this case is a word or group of syntax,
     * roughly correlating to the token structure returned by the WikiWho API.
     * @return string
     */
    public function getFirstQueryToken(): string
    {
        return strtolower(preg_split('/[\n\s]/', $this->query)[0]);
    }

    /**
     * Get the target revision that is being blamed.
     * @return Edit|null
     */
    public function getAsOf(): ?Edit
    {
        if (isset($this->asOf)) {
            return $this->asOf;
        }

        $this->asOf = $this->target
            ? $this->repository->getEditFromRevId($this->page, $this->target)

The method getEditFromRevId() does not exist on App\Repository\Repository. It seems like you code against a sub-type of App\Repository\Repository such as App\Repository\BlameRepository.

            : null;

        return $this->asOf;
    }

    /**
     * Get authorship attribution from the WikiWho API.
     * @see https://www.f-squared.org/wikiwho/
     */
    public function prepareData(): void
    {
        if (isset($this->matches)) {
            return;
        }

        // Set revision data. self::setRevisionData() returns null if there are errors.
        $revisionData = $this->getRevisionData(true);
        if (null === $revisionData) {
            return;
        }

        $matches = $this->searchTokens($revisionData['tokens']);

        // We want the results grouped by editor and revision ID.
        $this->matches = [];
        foreach ($matches as $match) {
            if (isset($this->matches[$match['id']])) {
                $this->matches[$match['id']]['tokens'][] = $match['token'];
                continue;
            }

            $edit = $this->repository->getEditFromRevId($this->page, $match['id']);
            if ($edit) {
                $this->matches[$match['id']] = [
                    'edit' => $edit,
                    'tokens' => [$match['token']],
                ];
            }
        }
    }

    /**
     * Find matches of search query in the given list of tokens.
     * @param array $tokens
     * @return array
     */
    private function searchTokens(array $tokens): array
    {
        $matchData = [];
        $matchDataSoFar = [];
        $matchSoFar = '';
        $firstQueryToken = $this->getFirstQueryToken();
        $tokenizedQuery = $this->getTokenizedQuery();

        foreach ($tokens as $token) {
            // The previous matches plus the new token. This is basically a candidate for what may become $matchSoFar.
            $newMatchSoFar = $matchSoFar.$token['str'];

            // We first check if the first token of the query matches, because we want to allow for partial matches
            // (e.g. for query "barbaz", the tokens ["foobar","baz"] should match).
            if (false !== strpos($newMatchSoFar, $firstQueryToken)) {
                // If the full query is in the new match, use it, otherwise use just the first token. This is because
                // the full match may exist across multiple tokens, but the first match is only a partial match.
                $newMatchSoFar = false !== strpos($newMatchSoFar, $tokenizedQuery)
                    ? $newMatchSoFar
                    : $firstQueryToken;
            }

            // Keep track of tokens that match. To allow partial matches,
            // we check the query against $newMatchSoFar and vice versa.
            if (false !== strpos($tokenizedQuery, $newMatchSoFar) ||
                false !== strpos($newMatchSoFar, $tokenizedQuery)
            ) {
                $matchSoFar = $newMatchSoFar;
                $matchDataSoFar[] = [
                    'id' => $token['o_rev_id'],
                    'editor' => $token['editor'],
                    'token' => $token['str'],
                ];
            } elseif (!empty($matchSoFar)) {
                // We hit a token that isn't in the query string, so start over.
                $matchDataSoFar = [];
                $matchSoFar = '';
            }

            // A full match was found, so merge $matchDataSoFar into $matchData,
            // and start over to see if there are more matches in the article.
            if (false !== strpos($matchSoFar, $tokenizedQuery)) {
                $matchData = array_merge($matchData, $matchDataSoFar);
                $matchDataSoFar = [];
                $matchSoFar = '';
            }
        }

        // Full matches usually come last, but are the most relevant.
        return array_reverse($matchData);
    }
}