AutoEdits::__construct() - Code Metrics - Inspection of "Fix failing linter test" - x-tools/xtools - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( a61c57...8dbe0a )

by MusikAnimal
created 2020-01-13 00:54 UTC
AutoEdits::__construct() A

↳ Parent: AutoEdits
Complexity

Conditions	3
Paths	4
Size

Total Lines	16
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	8
CRAP Score	3
Importance

Changes
Metric	Value
cc	3
eloc	7
nc	4
nop	7
dl	0
loc	16
ccs	8
cts	8
cp	1
crap	3
rs	10
c	0
b	0
f	0
<?php
/**
 * This file contains only the AutoEdits class.
 */

declare(strict_types = 1);

namespace AppBundle\Model;

/**
 * AutoEdits returns statistics about automated edits made by a user.
 */
class AutoEdits extends Model
{
    /** @var null|string The tool we're searching for when fetching (semi-)automated edits. */
    protected $tool;

    /** @var Edit[] The list of non-automated contributions. */
    protected $nonAutomatedEdits;

    /** @var Edit[] The list of automated contributions. */
    protected $automatedEdits;

    /** @var int Total number of edits. */
    protected $editCount;

    /** @var int Total number of non-automated edits. */
    protected $automatedCount;

    /** @var array Counts of known automated tools used by the given user. */
    protected $toolCounts;

    /** @var int Total number of edits made with the tools. */
    protected $toolsTotal;

    /**
     * Constructor for the AutoEdits class.
     * @param Project $project
     * @param User $user
     * @param int|string $namespace Namespace ID or 'all'
     * @param int|false $start Start date in a format accepted by strtotime()
     * @param int|false $end End date in a format accepted by strtotime()
     * @param string $tool The tool we're searching for when fetching (semi-)automated edits.
     * @param int|string $offset Used for pagination, offset results by N edits.
     */
    public function __construct(
        Project $project,
        User $user,
        $namespace = 0,
        $start = false,
        $end = false,
        $tool = null,
        $offset = 0
    ) {
        $this->project = $project;
        $this->user = $user;
        $this->namespace = $namespace;
        $this->start = false === $start ? '' : date('Y-m-d', $start);
        $this->end = false === $end ? '' : date('Y-m-d', $end);
        $this->tool = $tool;
        $this->offset = $offset;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    }

    /**
     * The tool we're limiting the results to when fetching
     * (semi-)automated contributions.
     * @return null|string
     */
    public function getTool(): ?string
    {
        return $this->tool;
    }

    /**
     * Get the raw edit count of the user.
     * @return int
     */
    public function getEditCount(): int
    {
        if (!is_int($this->editCount)) {

            $this->editCount = $this->user->countEdits(
                $this->project,
                $this->namespace,
                $this->start,
                $this->end
            );
        }

        return $this->editCount;
    }

    /**
     * Get the number of edits this user made using semi-automated tools.
     * This is not the same as self::getToolCounts because the regex can overlap.
     * @return int Result of query, see below.
     */
    public function getAutomatedCount(): int
    {
        if (is_int($this->automatedCount)) {

            return $this->automatedCount;
        }

        $this->automatedCount = (int)$this->getRepository()->countAutomatedEdits(
            $this->project,
            $this->user,
            $this->namespace,
            $this->start,
            $this->end
        );

        return $this->automatedCount;
    }

    /**
     * Get the percentage of all edits made using automated tools.
     * @return float
     */
    public function getAutomatedPercentage(): float
    {
        return $this->getEditCount() > 0
            ? ($this->getAutomatedCount() / $this->getEditCount()) * 100
            : 0;
    }

    /**
     * Get non-automated contributions for this user.
     * @param bool $raw Wether to return raw data from the database, or get Edit objects.
     * @return string[]|Edit[]
     */
    public function getNonAutomatedEdits(bool $raw = false)
    {
        if (is_array($this->nonAutomatedEdits)) {

            return $this->nonAutomatedEdits;
        }

        $revs = $this->getRepository()->getNonAutomatedEdits(
            $this->project,
            $this->user,
            $this->namespace,
            $this->start,
            $this->end,
            $this->offset
        );

        if ($raw) {
            return $revs;
        }

        $this->nonAutomatedEdits = Edit::getEditsFromRevs($this->project, $this->user, $revs);

        return $this->nonAutomatedEdits;
    }

    /**
     * Get automated contributions for this user.
     * @param bool $raw Whether to return raw data from the database, or get Edit objects.
     * @return Edit[]
     */
    public function getAutomatedEdits(bool $raw = false): array
    {
        if (is_array($this->automatedEdits)) {

            return $this->automatedEdits;
        }

        $revs = $this->getRepository()->getAutomatedEdits(
            $this->project,
            $this->user,
            $this->namespace,
            $this->start,
            $this->end,
            $this->tool,
            $this->offset
        );

        if ($raw) {
            return $revs;
        }

        $this->automatedEdits = Edit::getEditsFromRevs($this->project, $this->user, $revs);

        return $this->automatedEdits;
    }

    /**
     * Get counts of known automated tools used by the given user.
     * @return array Each tool that they used along with the count and link:
     *                  [
     *                      'Twinkle' => [
     *                          'count' => 50,
     *                          'link' => 'Wikipedia:Twinkle',
     *                      ],
     *                  ]
     */
    public function getToolCounts(): array
    {
        if (is_array($this->toolCounts)) {

            return $this->toolCounts;
        }

        $this->toolCounts = $this->getRepository()->getToolCounts(
            $this->project,
            $this->user,
            $this->namespace,
            $this->start,
            $this->end
        );

        return $this->toolCounts;
    }

    /**
     * Get a list of all available tools for the Project.
     * @return array
     */
    public function getAllTools(): array
    {
        return $this->getRepository()->getTools($this->project);
        return $this->getRepository()->/** @scrutinizer ignore-call */ getTools($this->project);
    }

    /**
     * Get the combined number of edits made with each tool. This is calculated separately from
     * self::getAutomatedCount() because the regex can sometimes overlap, and the counts are actually different.
     * @return int
     */
    public function getToolsTotal(): int
    {
        if (!is_int($this->toolsTotal)) {

            $this->toolsTotal = array_reduce($this->getToolCounts(), function ($a, $b) {
                return $a + $b['count'];
            });
        }

        return $this->toolsTotal;
    }
}

x-tools / xtools

Push — master ( a61c57...8dbe0a )

AutoEdits::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
