Xoco70\LaravelTournaments\TreeGen\DirectEliminationTreeGen

Complexity

Total Complexity

26

Size/Duplication

Total Lines	189
Duplicated Lines	12.17 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getNumRounds()	0	4	1
A	firstRoundGroupSize()	0	6	2
A	getByeGroup()	8	8	1
A	pushGroups()	14	14	3
A	pushEmptyGroupsToTree()	0	13	2
A	chunkAndShuffle()	0	15	3
B	generateFights()	0	22	4
A	generateAllTrees()	0	10	1
A	generateGroupsForRound()	0	17	4
B	minFightersCheck()	0	25	5

<?php

namespace Xoco70\LaravelTournaments\TreeGen;

use Illuminate\Support\Collection;
use Xoco70\LaravelTournaments\Exceptions\TreeGenerationException;
use Xoco70\LaravelTournaments\Models\ChampionshipSettings;
use Xoco70\LaravelTournaments\Models\DirectEliminationFight;
use Xoco70\LaravelTournaments\Models\PreliminaryFight;

abstract class DirectEliminationTreeGen extends TreeGen
{
    /**
     * Calculate the Byes need to fill the Championship Tree.
     *
     * @param $fighters
     *
     * @return Collection
     */
    protected function getByeGroup($fighters)

This method seems to be duplicated in your project.

    {
        $fighterCount = $fighters->count();
        $firstRoundGroupSize = $this->firstRoundGroupSize();
        $treeSize = $this->getTreeSize($fighterCount, $firstRoundGroupSize);
        $byeCount = $treeSize - $fighterCount;
        return $this->createByeGroup($byeCount);
    }

    /**
     * Save Groups with their parent info.
     *
     * @param int $numRounds
     * @param int $numFighters
     */
    protected function pushGroups($numRounds, $numFighters)

This method seems to be duplicated in your project.

    {
        // TODO Here is where you should change when enable several winners for preliminary
        for ($roundNumber = 2; $roundNumber <= $numRounds + 1; $roundNumber++) {
            // From last match to first match
            $maxMatches = ($numFighters / pow(2, $roundNumber));

            for ($matchNumber = 1; $matchNumber <= $maxMatches; $matchNumber++) {
                $fighters = $this->createByeGroup(2);
                $group = $this->saveGroup($matchNumber, $roundNumber, null);
                $this->syncGroup($group, $fighters);
            }
        }
    }

    /**
     * Create empty groups for direct Elimination Tree.
     *
     * @param $numFighters
     */
    protected function pushEmptyGroupsToTree($numFighters)
    {
        if ($this->championship->hasPreliminary()) {
            $numFightersElim = $numFighters / $this->championship->getSettings()->preliminaryGroupSize * 2;
            // We calculate how much rounds we will have
            $numRounds = intval(log($numFightersElim, 2)); // 3 rounds, but begining from round 2 ( ie => 4)
            return $this->pushGroups($numRounds, $numFightersElim);
        }
        // We calculate how much rounds we will have
        $numRounds = $this->getNumRounds($numFighters);

        return $this->pushGroups($numRounds, $numFighters);
    }

    /**
     * Chunk Fighters into groups for fighting, and optionnaly shuffle.
     *
     * @param $fightersByEntity
     *
     * @return Collection|null
     */
    protected function chunkAndShuffle(Collection $fightersByEntity)
    {
        //TODO Should Pull down to know if team or competitor
        if ($this->championship->hasPreliminary()) {
            return (new PlayOffCompetitorTreeGen($this->championship, null))->chunkAndShuffle($fightersByEntity);

The method chunkAndShuffle() cannot be called from this context as it is declared protected in class Xoco70\LaravelTournaments\TreeGen\PlayOffTreeGen.

        }
        $fightersGroup = null;

$fightersGroup is not used, you could remove the assignment.

        $fightersGroup = $fightersByEntity->chunk(2);
        if (!app()->runningUnitTests()) {
            $fightersGroup = $fightersGroup->shuffle();
        }

        return $fightersGroup;
    }

    /**
     * Generate First Round Fights.
     */
    protected function generateFights()
    {
        //  First Round Fights
        $settings = $this->championship->getSettings();
        $initialRound = 1;

        // Very specific case to common case : Preliminary with 3 fighters
        if ($this->championship->hasPreliminary() && $settings->preliminaryGroupSize == 3) {
            // First we make all first fights of all groups
            // Then we make all second fights of all groups
            // Then we make all third fights of all groups
            $groups = $this->championship->groupsByRound(1)->get();
            for ($numFight = 1; $numFight <= $settings->preliminaryGroupSize; $numFight++) {
                $fight = new PreliminaryFight();
                $fight->saveFights($groups, $numFight);
            }
            $initialRound++;
        }
        // Save Next rounds
        $fight = new DirectEliminationFight();
        $fight->saveFights($this->championship, $initialRound);
    }

    /**
     * Return number of rounds for the tree based on fighter count.
     *
     * @param $numFighters
     *
     * @return int
     */
    protected function getNumRounds($numFighters)
    {
        return intval(log($numFighters / $this->firstRoundGroupSize() * 2, 2));
    }

    private function firstRoundGroupSize()
    {
        return $this->championship->hasPreliminary()
            ? $this->championship->getSettings()->preliminaryGroupSize
            : 2;
    }

    protected function generateAllTrees()
    {
        $this->minFightersCheck();
        $usersByArea = $this->getFightersByArea();
        $numFighters = count($usersByArea->collapse());
        $this->generateGroupsForRound($usersByArea, 1);
        $this->pushEmptyGroupsToTree($numFighters); // Abstract
        $this->addParentToChildren($numFighters);

    }

    /**
     * @param Collection $usersByArea
     * @param $round
     */
    public function generateGroupsForRound(Collection $usersByArea, $round)
    {
        $order = 1;
        foreach ($usersByArea as $fightersByEntity) {
            // Chunking to make small round robin groups
            $chunkedFighters = $this->chunkAndShuffle($fightersByEntity);
            foreach ($chunkedFighters as $fighters) {

The expression $chunkedFighters of type object<Illuminate\Support\Collection>|null is not guaranteed to be traversable. How about adding an additional type check?

                $fighters = $fighters->pluck('id');
                if (!app()->runningUnitTests()) {
                    $fighters = $fighters->shuffle();
                }
                $group = $this->saveGroup($order, $round, null);
                $this->syncGroup($group, $fighters);
                $order++;
            }
        }
    }

    /**
     * Check if there is enough fighters, throw exception otherwise
     * @throws TreeGenerationException
     */
    private function minFightersCheck()
    {
        $fighters = $this->getFighters();
        $areas = $this->settings->fightingAreas;
        $fighterType = $this->settings->isTeam
            ? trans_choice('.team', 2)
            : trans_choice('laravel-tournaments::core.competitor', 2);

        $minFighterCount = $fighters->count() / $areas;


        if ($this->settings->hasPreliminary && $fighters->count() / ($this->settings->preliminaryGroupSize * $areas) < 1) {
            throw new TreeGenerationException(trans('laravel-tournaments::core.min_competitor_required', [
                'number' => $this->settings->preliminaryGroupSize * $areas,
                'fighter_type' => $fighterType
            ]));
        }

        if ($minFighterCount < ChampionshipSettings::MIN_COMPETITORS_BY_AREA) {
            throw new TreeGenerationException(trans('laravel-tournaments::core.min_competitor_required', [
                'number' => ChampionshipSettings::MIN_COMPETITORS_BY_AREA,
                'fighter_type' => $fighterType
            ]));
        }
    }
}