ArticleInfo::setTopTenCounts() - Code Metrics - Inspection of "Merge pull request #97 from x-tools/max-revisions-..." - x-tools/xtools - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 3af732...89cc2d )

by MusikAnimal
created 2017-10-03 02:48 UTC
ArticleInfo::setTopTenCounts() C

↳ Parent: ArticleInfo
Complexity

Conditions	8
Paths	17
Size

Total Lines	69
Code Lines	38
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	69
rs	6.5437
c	0
b	0
f	0
cc	8
eloc	38
nc	17
nop	0
How to fix Long Method

<?php
/**
 * This file contains only the ArticleInfo class.
 */

namespace Xtools;

use Symfony\Component\DependencyInjection\Container;
use DateTime;

/**
 * An ArticleInfo provides statistics about a page on a project. This model does not
 * have a separate Repository because it needs to use individual SQL statements to
 * traverse the page's history, saving class instance variables along the way.
 */
class ArticleInfo extends Model
{
    /** @var Container The application's DI container. */
    protected $container;

    /** @var Page The page. */
    protected $page;

    /** @var int Number of revisions that belong to the page. */
    protected $numRevisions;

    /** @var int Maximum number of revisions to process, as configured. */
    protected $maxRevisions;

    /** @var int Number of revisions that were actually processed. */
    protected $numRevisionsProcessed;

    /**
     * Various statistics about editors to the page. These are not User objects
     * so as to preserve memory.
     * @var mixed[]
     */
    protected $editors;

    /** @var mixed[] The top 10 editors to the page by number of edits. */
    protected $topTenEditorsByEdits;

    /** @var mixed[] The top 10 editors to the page by added text. */
    protected $topTenEditorsByAdded;

    /** @var int Number of edits made by the top 10 editors. */
    protected $topTenCount;

    /** @var mixed[] Various statistics about bots that edited the page. */
    protected $bots;

    /** @var int Number of edits made to the page by bots. */
    protected $botRevisionCount;

    /** @var mixed[] Various counts about each individual year and month of the page's history. */
    protected $yearMonthCounts;

    /** @var Edit The first edit to the page. */
    protected $firstEdit;

    /** @var Edit The last edit to the page. */
    protected $lastEdit;

    /** @var Edit Edit that made the largest addition by number of bytes. */
    protected $maxAddition;

    /** @var Edit Edit that made the largest deletion by number of bytes. */
    protected $maxDeletion;

    /** @var int[] Number of in and outgoing links and redirects to the page. */
    protected $linksAndRedirects;

    /** @var string[] Assessments of the page (see Page::getAssessments). */
    protected $assessments;

    /**
     * Maximum number of edits that were created across all months. This is used as a comparison
     * for the bar charts in the months section.
     * @var int
     */
    protected $maxEditsPerMonth;

    /** @var string[] List of (semi-)automated tools that were used to edit the page. */
    protected $tools;

    /**
     * Total number of bytes added throughout the page's history. This is used as a comparison
     * when computing the top 10 editors by added text.
     * @var int
     */
    protected $addedBytes = 0;

    /** @var int Number of days between first and last edit. */
    protected $totalDays;

    /** @var int Number of minor edits to the page. */
    protected $minorCount = 0;

    /** @var int Number of anonymous edits to the page. */
    protected $anonCount = 0;

    /** @var int Number of automated edits to the page. */
    protected $automatedCount = 0;

    /** @var int Number of edits to the page that were reverted with the subsequent edit. */
    protected $revertCount = 0;

    /** @var int[] The "edits per <time>" counts. */
    protected $countHistory = [
        'day' => 0,
        'week' => 0,
        'month' => 0,
        'year' => 0
    ];

    /** @var string[] List of wikidata and Checkwiki errors. */
    protected $bugs;

    /**
     * ArticleInfo constructor.
     * @param Page $page The page to process.
     * @param Container $container The DI container.
     */
    public function __construct(Page $page, Container $container)
    {
        $this->page = $page;
        $this->container = $container;
        $this->conn = $this->container
class MyClass { }

$x = new MyClass();
$x->foo = true;
            ->get('doctrine')
            ->getManager('replicas')
            ->getConnection();
    }

    /**
     * Shorthand to get the page's project.
     * @return Project
     */
    public function getProject()
    {
        return $this->page->getProject();
    }

    /**
     * Get the number of revisions belonging to the page.
     * @return int
     */
    public function getNumRevisions()
    {
        if (!isset($this->numRevisions)) {
            $this->numRevisions = $this->page->getNumRevisions();
        }
        return $this->numRevisions;
    }

    /**
     * Get the maximum number of revisions that we should process.
     * @return int
     */
    public function getMaxRevisions()
    {
        if (!isset($this->maxRevisions)) {
            $this->maxRevisions = (int) $this->container->getParameter('app.max_page_revisions');
        }
        return $this->maxRevisions;
    }

    /**
     * Get the number of revisions that are actually getting processed.
     * This goes by the app.max_page_revisions parameter, or the actual
     * number of revisions, whichever is smaller.
     * @return int
     */
    public function getNumRevisionsProcessed()
    {
        if (isset($this->numRevisionsProcessed)) {
            return $this->numRevisionsProcessed;
        }

        if ($this->tooManyRevisions()) {
            $this->numRevisionsProcessed = $this->getMaxRevisions();
        } else {
            $this->numRevisionsProcessed = $this->getNumRevisions();
        }

        return $this->numRevisionsProcessed;
    }

    /**
     * Are there more revisions than we should process, based on the config?
     * @return bool
     */
    public function tooManyRevisions()
    {
        return $this->getMaxRevisions() > 0 && $this->getNumRevisions() > $this->getMaxRevisions();
    }

    /**
     * Fetch and store all the data we need to show the ArticleInfo view.
     */
    public function prepareData()
    {
        $this->parseHistory();
        $this->setLogsEvents();
        $this->setTopTenCounts();
        $this->bots = $this->getBotData();
    }

    /**
     * Get the number of editors that edited the page.
     * @return int
     */
    public function numEditors()
    {
        return count($this->editors);
    }

    /**
     * Get the number of bots that edited the page.
     * @return int
     */
    public function numBots()
    {
        return count($this->bots);
    }

    /**
     * Get the number of days between the first and last edit.
     * @return int
     */
    public function getTotalDays()
    {
        if (isset($this->totalDays)) {
            return $this->totalDays;
        }
        $dateFirst = $this->firstEdit->getTimestamp();
        $dateLast = $this->lastEdit->getTimestamp();
        $interval = date_diff($dateLast, $dateFirst, true);
        return $interval->format('%a');
    }

    /**
     * Get the average number of days between edits to the page.
     * @return double
     */
    public function averageDaysPerEdit()
    {
        return round($this->getTotalDays() / $this->getNumRevisions(), 1);
    }

    /**
     * Get the average number of edits per day to the page.
     * @return double
     */
    public function editsPerDay()
    {
        $editsPerDay = $this->getTotalDays()
            ? $this->getNumRevisions() / ($this->getTotalDays() / (365 / 12 / 24))
            : 0;
        return round($editsPerDay, 1);
    }

    /**
     * Get the average number of edits per month to the page.
     * @return double
     */
    public function editsPerMonth()
    {
        $editsPerMonth = $this->getTotalDays()
            ? $this->getNumRevisions() / ($this->getTotalDays() / (365 / 12))
            : 0;
        return round($editsPerMonth, 1);
    }

    /**
     * Get the average number of edits per year to the page.
     * @return double
     */
    public function editsPerYear()
    {
        $editsPerYear = $this->getTotalDays()
            ? $this->getNumRevisions() / ($this->getTotalDays() / 365)
            : 0;
        return round($editsPerYear, 1);
    }

    /**
     * Get the average number of edits per editor.
     * @return double
     */
    public function editsPerEditor()
    {
        return round($this->getNumRevisions() / count($this->editors), 1);
    }

    /**
     * Get the percentage of minor edits to the page.
     * @return double
     */
    public function minorPercentage()
    {
        return round(
            ($this->minorCount / $this->getNumRevisions()) * 100,
            1
        );
    }

    /**
     * Get the percentage of anonymous edits to the page.
     * @return double
     */
    public function anonPercentage()
    {
        return round(
            ($this->anonCount / $this->getNumRevisions()) * 100,
            1
        );
    }

    /**
     * Get the percentage of edits made by the top 10 editors.
     * @return double
     */
    public function topTenPercentage()
    {
        return round(($this->topTenCount / $this->getNumRevisions()) * 100, 1);
    }

    /**
     * Get the number of times the page has been viewed in the given timeframe.
     * @param  int $latest Last N days.
     * @return int
     */
    public function getPageviews($latest)
    {
        return $this->page->getLastPageviews($latest);
    }

    /**
     * Get the page assessments of the page.
     * @see https://www.mediawiki.org/wiki/Extension:PageAssessments
     * @return string[]|false False if unsupported.
     */
    public function getAssessments()
    {
        if (!is_array($this->assessments)) {
            $this->assessments = $this->page->getAssessments();
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;
}
        }
        return $this->assessments;
    }

    /**
     * Get the number of automated edits made to the page.
     * @return int
     */
    public function getAutomatedCount()
    {
        return $this->automatedCount;
    }

    /**
     * Get the number of edits to the page that were reverted with the subsequent edit.
     * @return int
     */
    public function getRevertCount()
    {
        return $this->revertCount;
    }

    /**
     * Get the number of edits to the page made by logged out users.
     * @return int
     */
    public function getAnonCount()
    {
        return $this->anonCount;
    }

    /**
     * Get the number of minor edits to the page.
     * @return int
     */
    public function getMinorCount()
    {
        return $this->minorCount;
    }

    /**
     * Get the number edits to the page made by bots.
     * @return int
     */
    public function getBotRevisionCount()
    {
        return $this->botRevisionCount;
    }

    /**
     * Get the number of edits to the page made in the past day, week, month and year.
     * @return int[] With keys 'day', 'week', 'month' and 'year'.
     */
    public function getCountHistory()
    {
        return $this->countHistory;
    }

    /**
     * Get the number of edits to the page made by the top 10 editors.
     * @return int
     */
    public function getTopTenCount()
    {
        return $this->topTenCount;
    }

    /**
     * Get the first edit to the page.
     * @return Edit
     */
    public function getFirstEdit()
    {
        return $this->firstEdit;
    }

    /**
     * Get the last edit to the page.
     * @return Edit
     */
    public function getLastEdit()
    {
        return $this->lastEdit;
    }

    /**
     * Get the edit that made the largest addition to the page (by number of bytes).
     * @return Edit
     */
    public function getMaxAddition()
    {
        return $this->maxAddition;
    }

    /**
     * Get the edit that made the largest removal to the page (by number of bytes).
     * @return Edit
     */
    public function getMaxDeletion()
    {
        return $this->maxDeletion;
    }

    /**
     * Get the list of editors to the page, including various statistics.
     * @return mixed[]
     */
    public function getEditors()
    {
        return $this->editors;
    }

    /**
     * Get the list of the top editors to the page (by edits), including various statistics.
     * @return mixed[]
     */
    public function topTenEditorsByEdits()
    {
        return $this->topTenEditorsByEdits;
    }

    /**
     * Get the list of the top editors to the page (by added text), including various statistics.
     * @return mixed[]
     */
    public function topTenEditorsByAdded()
    {
        return $this->topTenEditorsByAdded;
    }

    /**
     * Get the list of bots that edited the page, including various statistics.
     * @return mixed[]
     */
    public function getBots()
    {
        return $this->bots;
    }

    /**
     * Get various counts about each individual year and month of the page's history.
     * @return mixed[]
     */
    public function getYearMonthCounts()
    {
        return $this->yearMonthCounts;
    }

    /**
     * Get the maximum number of edits that were created across all months. This is used as a
     * comparison for the bar charts in the months section.
     * @return int
     */
    public function getMaxEditsPerMonth()
    {
        return $this->maxEditsPerMonth;
    }

    /**
     * Get a list of (semi-)automated tools that were used to edit the page, including
     * the number of times they were used, and a link to the tool's homepage.
     * @return mixed[]
     */
    public function getTools()
    {
        return $this->tools;
    }

    /**
     * Get the list of page's wikidata and Checkwiki errors.
     * @see Page::getErrors()
     * @return string[]
     */
    public function getBugs()
    {
        if (!is_array($this->bugs)) {
            $this->bugs = $this->page->getErrors();
        }
        return $this->bugs;
    }

    /**
     * Get the number of wikidata nad CheckWiki errors.
     * @return int
     */
    public function numBugs()
    {
        return count($this->getBugs());
    }

    /**
     * Get the number of external links on the page.
     * @return int
     */
    public function linksExtCount()
    {
        return $this->getLinksAndRedirects()['links_ext_count'];
    }

    /**
     * Get the number of incoming links to the page.
     * @return int
     */
    public function linksInCount()
    {
        return $this->getLinksAndRedirects()['links_in_count'];
    }

    /**
     * Get the number of outgoing links from the page.
     * @return int
     */
    public function linksOutCount()
    {
        return $this->getLinksAndRedirects()['links_out_count'];
    }

    /**
     * Get the number of redirects to the page.
     * @return int
     */
    public function redirectsCount()
    {
        return $this->getLinksAndRedirects()['redirects_count'];
    }

    /**
     * Get the number of external, incoming and outgoing links, along with
     * the number of redirects to the page.
     * @return int
     */
    private function getLinksAndRedirects()
    {
        if (!is_array($this->linksAndRedirects)) {
            $this->linksAndRedirects = $this->page->countLinksAndRedirects();

        }
        return $this->linksAndRedirects;
    }

    /**
     * Parse the revision history, collecting our core statistics.
     * @todo Break this out into separate functions, perhaps with the loop body
     *   as a separate class.
     * @return mixed[] Associative "master" array of metadata about the page.
     */
    private function parseHistory()
    {
        if ($this->tooManyRevisions()) {
            $limit = $this->getMaxRevisions();
        } else {
            $limit = null;
        }
        // Third parameter is ignored if $limit is null.
        $revStmt = $this->page->getRevisionsStmt(null, $limit, $this->getNumRevisions());
        $revCount = 0;

        /** @var Edit|null The previous edit, used to discount content that was reverted */
        $prevEdit = null;

        /**
         * The edit previously deemed as having the maximum amount of content added.
         * This is used to discount content that was reverted.
         * @var Edit|null
        */
        $prevMaxAddEdit = null;

        /**
         * The edit previously deemed as having the maximum amount of content deleted.
         * This is used to discount content that was reverted
         * @var Edit|null
         */
        $prevMaxDelEdit = null;

        /** @var Time|null Time of first revision, used as a comparison for month counts */
        $firstEditMonth = null;

        while ($rev = $revStmt->fetch()) {
            $edit = new Edit($this->page, $rev);

            // Some shorthands
            $editYear = $edit->getYear();
            $editMonth = $edit->getMonth();
            $editTimestamp = $edit->getTimestamp();

            // Don't return actual edit size if last revision had a length of null.
            // This happens when the edit follows other edits that were revision-deleted.
            // See T148857 for more information.
            // @TODO: Remove once T101631 is resolved
            if ($prevEdit && $prevEdit->getLength() === null) {
                $editSize = 0;
            } else {
                $editSize = $edit->getSize();
            }

            if ($revCount === 0) {
                $this->firstEdit = $edit;
                $firstEditMonth = mktime(0, 0, 0, (int) $this->firstEdit->getMonth(), 1, $this->firstEdit->getYear());
            }

            $username = $edit->getUser()->getUsername();

            // Sometimes, with old revisions (2001 era), the revisions from 2002 come before 2001
            if ($editTimestamp < $this->firstEdit->getTimestamp()) {
                $this->firstEdit = $edit;
            }

            // Fill in the blank arrays for the year and 12 months
            if (!isset($this->yearMonthCounts[$editYear])) {
                $this->yearMonthCounts[$editYear] = [
                    'all' => 0,
                    'minor' => 0,
                    'anon' => 0,
                    'automated' => 0,
                    'size' => 0, // keep track of the size by the end of the year
                    'events' => [],
                    'months' => [],
                ];

                for ($i = 1; $i <= 12; $i++) {
                    $timeObj = mktime(0, 0, 0, $i, 1, $editYear);

                    // don't show zeros for months before the first edit or after the current month
                    if ($timeObj < $firstEditMonth || $timeObj > strtotime('last day of this month')) {
                        continue;
                    }

                    $this->yearMonthCounts[$editYear]['months'][sprintf('%02d', $i)] = [
                        'all' => 0,
                        'minor' => 0,
                        'anon' => 0,
                        'automated' => 0,
                    ];
                }
            }

            // Increment year and month counts for all edits
            $this->yearMonthCounts[$editYear]['all']++;
            $this->yearMonthCounts[$editYear]['months'][$editMonth]['all']++;
            // This will ultimately be the size of the page by the end of the year
            $this->yearMonthCounts[$editYear]['size'] = $edit->getLength();

            // Keep track of which month had the most edits
            $editsThisMonth = $this->yearMonthCounts[$editYear]['months'][$editMonth]['all'];
            if ($editsThisMonth > $this->maxEditsPerMonth) {
                $this->maxEditsPerMonth = $editsThisMonth;
            }

            // Initialize various user stats
            if (!isset($this->editors[$username])) {
                $this->editors[$username] = [
                    'all' => 0,
                    'minor' => 0,
                    'minorPercentage' => 0,
                    'first' => $editTimestamp,
                    'firstId' => $edit->getId(),
                    'last' => null,
                    'atbe' => null,
                    'added' => 0,
                    'sizes' => [],
                ];
            }

            // Increment user counts
            $this->editors[$username]['all']++;
            $this->editors[$username]['last'] = $editTimestamp;
            $this->editors[$username]['lastId'] = $edit->getId();

            // Store number of KB added with this edit
            $this->editors[$username]['sizes'][] = $edit->getLength() / 1024;

            // Check if it was a revert
            if ($edit->isRevert($this->container)) {
                $this->revertCount++;

                // Since this was a revert, we don't want to treat the previous
                //   edit as legit content addition or removal
                if ($prevEdit && $prevEdit->getSize() > 0) {
                    $this->addedBytes -= $prevEdit->getSize();
                }

                // @TODO: Test this against an edit war (use your sandbox)
                // Also remove as max added or deleted, if applicable
                if ($this->maxAddition && $prevEdit->getId() === $this->maxAddition->getId()) {
                    $this->maxAddition = $prevMaxAddEdit;
                    $prevMaxAddEdit = $prevEdit; // in the event of edit wars
                } elseif ($this->maxDeletion &&
                    $prevEdit->getId() === $this->maxDeletion->getId()
                ) {
                    $this->maxDeletion = $prevMaxDelEdit;
                    $prevMaxDelEdit = $prevEdit; // in the event of edit wars
                }
            } else {
                // Edit was not a revert, so treat size > 0 as content added
                if ($editSize > 0) {
                    $this->addedBytes += $editSize;
                    $this->editors[$username]['added'] += $editSize;

                    // Keep track of edit with max addition
                    if (!$this->maxAddition || $editSize > $this->maxAddition->getSize()) {
                        // Keep track of old maxAddition in case we find out the next $edit was reverted
                        //   (and was also a max edit), in which case we'll want to use this one ($edit)
                        $prevMaxAddEdit = $this->maxAddition;

                        $this->maxAddition = $edit;
                    }
                } elseif ($editSize < 0 && (
                    !$this->maxDeletion || $editSize < $this->maxDeletion->getSize()
                )) {
                    $this->maxDeletion = $edit;
                }
            }

            // If anonymous, increase counts
            if ($edit->isAnon()) {
                $this->anonCount++;
                $this->yearMonthCounts[$editYear]['anon']++;
                $this->yearMonthCounts[$editYear]['months'][$editMonth]['anon']++;
            }

            // If minor edit, increase counts
            if ($edit->isMinor()) {
                $this->minorCount++;
                $this->yearMonthCounts[$editYear]['minor']++;
                $this->yearMonthCounts[$editYear]['months'][$editMonth]['minor']++;

                // Increment minor counts for this user
                $this->editors[$username]['minor']++;
            }

            $automatedTool = $edit->getTool($this->container);
            if ($automatedTool !== false) {
                $this->automatedCount++;
                $this->yearMonthCounts[$editYear]['automated']++;
                $this->yearMonthCounts[$editYear]['months'][$editMonth]['automated']++;

                if (!isset($this->tools[$automatedTool['name']])) {
                    $this->tools[$automatedTool['name']] = [
                        'count' => 1,
                        'link' => $automatedTool['link'],
                    ];
                } else {
                    $this->tools[$automatedTool['name']]['count']++;
                }
            }

            // Increment "edits per <time>" counts
            if ($editTimestamp > new DateTime('-1 day')) {
                $this->countHistory['day']++;
            }
            if ($editTimestamp > new DateTime('-1 week')) {
                $this->countHistory['week']++;
            }
            if ($editTimestamp > new DateTime('-1 month')) {
                $this->countHistory['month']++;
            }
            if ($editTimestamp > new DateTime('-1 year')) {
                $this->countHistory['year']++;
            }

            $revCount++;
            $prevEdit = $edit;
            $this->lastEdit = $edit;
        }

        // Various sorts
        arsort($this->editors);
        ksort($this->yearMonthCounts);
        if ($this->tools) {

            arsort($this->tools);
        }
    }

    /**
     * Get info about bots that edited the page.
     * This also sets $this->botRevisionCount and $this->botPercentage.
     * @return mixed[] Contains the bot's username, edit count to the page,
     *   and whether or not they are currently a bot.
     */
    private function getBotData()
    {
        $userGroupsTable = $this->getProject()->getTableName('user_groups');
        $userFromerGroupsTable = $this->getProject()->getTableName('user_former_groups');
        $sql = "SELECT COUNT(rev_user_text) AS count, rev_user_text AS username, ug_group AS current
                FROM " . $this->getProject()->getTableName('revision') . "
                LEFT JOIN $userGroupsTable ON rev_user = ug_user
                LEFT JOIN $userFromerGroupsTable ON rev_user = ufg_user
                WHERE rev_page = :pageId AND (ug_group = 'bot' OR ufg_group = 'bot')
                GROUP BY rev_user_text";
        $resultQuery = $this->conn->prepare($sql);
        $pageId = $this->page->getId();
        $resultQuery->bindParam('pageId', $pageId);
        $resultQuery->execute();

        // Parse the botedits
        $bots = [];
        $sum = 0;
        while ($bot = $resultQuery->fetch()) {
            $bots[$bot['username']] = [
                'count' => (int) $bot['count'],
                'current' => $bot['current'] === 'bot'
            ];
            $sum += $bot['count'];
        }

        uasort($bots, function ($a, $b) {
            return $b['count'] - $a['count'];
        });

        $this->botRevisionCount = $sum;
        $this->botPercentage = round(
class MyClass { }

$x = new MyClass();
$x->foo = true;
            // FIXME: should be processed revisions
            ($sum / $this->getNumRevisions()) * 100,
            1
        );

        return $bots;
    }

    /**
     * Query for log events during each year of the article's history,
     *   and set the results in $this->yearMonthCounts.
     */
    private function setLogsEvents()
    {
        $loggingTable = $this->getProject()->getTableName('logging', 'logindex');
        $title = str_replace(' ', '_', $this->page->getTitle());
        $sql = "SELECT log_action, log_type, log_timestamp AS timestamp
                FROM $loggingTable
                WHERE log_namespace = '" . $this->page->getNamespace() . "'
                AND log_title = :title AND log_timestamp > 1
                AND log_type IN ('delete', 'move', 'protect', 'stable')";
        $resultQuery = $this->conn->prepare($sql);
        $resultQuery->bindParam(':title', $title);
        $resultQuery->execute();

        while ($event = $resultQuery->fetch()) {
            $time = strtotime($event['timestamp']);
            $year = date('Y', $time);
            if (isset($this->yearMonthCounts[$year])) {
                $yearEvents = $this->yearMonthCounts[$year]['events'];

                // Convert log type value to i18n key
                switch ($event['log_type']) {
                    case 'protect':
                        $action = 'protections';
                        break;
                    case 'delete':
                        $action = 'deletions';
                        break;
                    case 'move':
                        $action = 'moves';
                        break;
                    // count pending-changes protections along with normal protections
                    case 'stable':
                        $action = 'protections';
                        break;
                }

                if (empty($yearEvents[$action])) {
                    $yearEvents[$action] = 1;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                } else {
                    $yearEvents[$action]++;
                }

                $this->yearMonthCounts[$year]['events'] = $yearEvents;
            }
        }
    }

    /**
     * Set statistics about the top 10 editors by added text and number of edits.
     * This is ran *after* parseHistory() since we need the grand totals first.
     * Various stats are also set for each editor in $this->editors to be used in the charts.
     * @return integer Number of edits
     */
    private function setTopTenCounts()
    {
        $topTenCount = $counter = 0;
        $topTenEditors = [];

        foreach ($this->editors as $editor => $info) {
            // Count how many users are in the top 10% by number of edits
            if ($counter < 10) {
                $topTenCount += $info['all'];
                $counter++;

                // To be used in the Top Ten charts
                $topTenEditors[] = [
                    'label' => $editor,
                    'value' => $info['all'],
                    'percentage' => (
                        100 * ($info['all'] / $this->getNumRevisions())
                    )
                ];
            }

            // Compute the percentage of minor edits the user made
            $this->editors[$editor]['minorPercentage'] = $info['all']
                ? ($info['minor'] / $info['all']) * 100
                : 0;

            if ($info['all'] > 1) {
                // Number of seconds/days between first and last edit
                $secs = $info['last']->getTimestamp() - $info['first']->getTimestamp();
                $days = $secs / (60 * 60 * 24);

                // Average time between edits (in days)
                $this->editors[$editor]['atbe'] = $days / $info['all'];
            }

            if (count($info['sizes'])) {
                // Average Total KB divided by number of stored sizes (user's edit count to this page)
                $this->editors[$editor]['size'] = array_sum($info['sizes']) / count($info['sizes']);
            } else {
                $this->editors[$editor]['size'] = 0;
            }
        }

        $this->topTenEditorsByEdits = $topTenEditors;

        // First sort editors array by the amount of text they added
        $topTenEditorsByAdded = $this->editors;
        uasort($topTenEditorsByAdded, function ($a, $b) {
            if ($a['added'] === $b['added']) {
                return 0;
            }
            return $a['added'] > $b['added'] ? -1 : 1;
        });

        // Then build a new array of top 10 editors by added text,
        //   in the data structure needed for the chart
        $this->topTenEditorsByAdded = array_map(function ($editor) {
            $added = $this->editors[$editor]['added'];
            return [
                'label' => $editor,
                'value' => $added,
                'percentage' => (
                    100 * ($added / $this->addedBytes)
                )
            ];
        }, array_keys(array_slice($topTenEditorsByAdded, 0, 10)));

        $this->topTenCount = $topTenCount;
    }
}

x-tools / xtools

Push — master ( 3af732...89cc2d )

ArticleInfo::setTopTenCounts() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Available Fixes

Duplication Side-by-Side

Filter issues like
