CondorcetPHP\Condorcet\ElectionProcess\VotesProcess

Complexity

Total Complexity

65

Size/Duplication

Total Lines	331
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

97.22%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	countVotes()	0	4	1
A	countInvalidVoteWithConstraints()	0	4	1
A	countValidVoteWithConstraints()	0	4	1
A	sumVotesWeight()	0	4	1
A	sumValidVotesWeightWithConstraints()	0	4	1
A	getVotesList()	0	4	1
A	getVotesListAsString()	0	4	1
A	getVotesManager()	0	4	1
A	getVotesListGenerator()	0	4	1
A	getVoteKey()	0	4	1
A	addVote()	0	12	3
A	prepareUpdateVote()	0	4	1
A	finishUpdateVote()	0	8	2
B	checkVoteCandidate()	0	26	11
A	convertRankingCandidates()	0	17	6
A	registerVote()	0	16	2
A	removeVotes()	0	17	2
A	removeVotesByTags()	0	19	2
A	prepareVoteInput()	0	11	3
C	addVotesFromJson()	0	50	12
C	parseVotes()	0	65	11

<?php
/*
    Condorcet PHP - Election manager and results calculator.
    Designed for the Condorcet method. Integrating a large number of algorithms extending Condorcet. Expandable for all types of voting systems.

    By Julien Boudry and contributors - MIT LICENSE (Please read LICENSE.txt)
    https://github.com/julien-boudry/Condorcet
*/
declare(strict_types=1);

namespace CondorcetPHP\Condorcet\ElectionProcess;

use CondorcetPHP\Condorcet\{CondorcetUtil, Vote};
use CondorcetPHP\Condorcet\DataManager\VotesManager;
use CondorcetPHP\Condorcet\Throwable\{CondorcetException, CondorcetInternalException};

// Manage Results for Election class
trait VotesProcess
{

/////////// CONSTRUCTOR ///////////

    // Data and global options
    protected $_Votes; // Votes list
    protected $_voteFastMode = false; // When parsing vote, avoid unnecessary checks 


/////////// VOTES LIST ///////////

    // How many votes are registered ?
    public function countVotes ($tags = null, bool $with = true) : int
    {
        return $this->_Votes->countVotes(VoteUtil::tagsConvert($tags),$with);
    }

    public function countInvalidVoteWithConstraints () : int
    {
        return $this->_Votes->countInvalidVoteWithConstraints();
    }

    public function countValidVoteWithConstraints () : int
    {
        return $this->countVotes() - $this->countInvalidVoteWithConstraints();
    }

    // Sum votes weight
    public function sumVotesWeight () : int
    {
        return $this->_Votes->sumVotesWeight(false);
    }

    public function sumValidVotesWeightWithConstraints () : int
    {
        return $this->_Votes->sumVotesWeight(true);
    }

    // Get the votes registered list
    public function getVotesList ($tags = null, bool $with = true) : array
    {
        return $this->_Votes->getVotesList(VoteUtil::tagsConvert($tags), $with);
    }

    public function getVotesListAsString () : string
    {
        return $this->_Votes->getVotesListAsString();
    }

    public function getVotesManager () : VotesManager
    {
        return $this->_Votes;
    }

    public function getVotesListGenerator ($tags = null, bool $with = true) : \Generator
    {
        return $this->_Votes->getVotesListGenerator(VoteUtil::tagsConvert($tags), $with);
    }

    public function getVoteKey (Vote $vote) : ?int
    {
        return $this->_Votes->getVoteKey($vote);
    }


/////////// ADD & REMOVE VOTE ///////////

    // Add a single vote. Array key is the rank, each candidate in a rank are separate by ',' It is not necessary to register the last rank.
    public function addVote ($vote, $tags = null) : Vote
    {
        $this->prepareVoteInput($vote, $tags);

        // Check Max Vote Count
        if ( self::$_maxVoteNumber !== null && $this->countVotes() >= self::$_maxVoteNumber ) :
            throw new CondorcetException(16, (string) self::$_maxVoteNumber);
        endif;

        // Register vote
        return $this->registerVote($vote, $tags); // Return the vote object
    }

    public function prepareUpdateVote (Vote $existVote) : void
    {
        $this->_Votes->UpdateAndResetComputing($this->getVoteKey($existVote),2);
    }

    public function finishUpdateVote (Vote $existVote) : void
    {
        $this->_Votes->UpdateAndResetComputing($this->getVoteKey($existVote),1);

        if ($this->_Votes->isUsingHandler()) :
            $this->_Votes[$this->getVoteKey($existVote)] = $existVote;
        endif;
    }

    public function checkVoteCandidate (Vote $vote) : bool
    {
        if (!$this->_voteFastMode) :
            $linkCount = $vote->countLinks();
            $links = $vote->getLinks();
            $linkCheck = ( $linkCount === 0 || ($linkCount === 1 && reset($links) === $this) );

            foreach ($vote->getAllCandidates() as $candidate) :
                if (!$linkCheck && $candidate->getProvisionalState() && !$this->isRegisteredCandidate($candidate, true) && $this->isRegisteredCandidate($candidate, false)) :

It seems like isRegisteredCandidate() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                    return false;
                endif;
            endforeach;
        endif;

        $ranking = $vote->getRanking();

        $change = $this->convertRankingCandidates($ranking);

        if ($change) :
            $vote->setRanking(  $ranking,
                                ( abs($vote->getTimestamp() - microtime(true)) > 0.5 ) ? ($vote->getTimestamp() + 0.001) : null
            );
        endif;

        return true;
    }

    public function convertRankingCandidates (array &$ranking) : bool
    {
        $change = false;

        foreach ($ranking as $rank => &$choice) :
            foreach ($choice as $choiceKey => &$candidate) :
                if ( !$this->isRegisteredCandidate($candidate, true) ) :

It seems like isRegisteredCandidate() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                    if ($candidate->getProvisionalState() && $this->isRegisteredCandidate($candidate, false)) :

It seems like isRegisteredCandidate() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                            $candidate = $this->_Candidates[$this->getCandidateKey((string) $candidate)];

The property _Candidates does not exist. Did you maybe forget to declare it?

It seems like getCandidateKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                            $change = true;
                    endif;
                endif;
            endforeach;
        endforeach;

        return $change;
    }

    // Write a new vote
    protected function registerVote (Vote $vote, $tag = null) : Vote
    {
        // Vote identifiant
        $vote->addTags($tag);
        
        // Register
        try {
            $vote->registerLink($this);
            $this->_Votes[] = $vote;
        } catch (CondorcetInternalException $e) {
            // Security : Check if vote object not already register
            throw new CondorcetException(31);
        }

        return $vote;
    }

    public function removeVotes (Vote $votes_input) : bool
    {    
        $key = $this->getVoteKey($votes_input);
        if ($key !== null) :
            $deletedVote = $this->_Votes[$key];
            $rem[] = $deletedVote;

$rem was never initialized. Although not strictly required by PHP, it is generally a good practice to add $rem = array(); before regardless.

            unset($this->_Votes[$key]);

            $deletedVote->destroyLink($this);

            return true;
        else :
            throw new CondorcetException(33);
        endif;

    }

    public function removeVotesByTags ($tags, bool $with = true) : array
    {    
        $rem = [];

        // Prepare Tags
        $tags = VoteUtil::tagsConvert($tags);

        // Deleting
        foreach ($this->getVotesList($tags, $with) as $key => $value) :
            $deletedVote = $this->_Votes[$key];
            $rem[] = $deletedVote;

            unset($this->_Votes[$key]);

            $deletedVote->destroyLink($this);
        endforeach;

        return $rem;
    }


/////////// PARSE VOTE ///////////

    // Return the well formated vote to use.
    protected function prepareVoteInput (&$vote, $tag = null) : void
    {
        if (!($vote instanceof Vote)) :
            $vote = new Vote ($vote, $tag, null, $this);
        endif;

        // Check array format && Make checkVoteCandidate
        if ( !$this->checkVoteCandidate($vote) ) :
            throw new CondorcetException(5);
        endif;
    }

    public function addVotesFromJson (string $input) : int
    {
        $input = CondorcetUtil::prepareJson($input);

            //////

        $adding = [];
        $count = 0;

        foreach ($input as $record) :
            if (empty($record['vote'])) :
                continue;
            endif;

            $tags = !isset($record['tag']) ? null : $record['tag'];
            $multiple = !isset($record['multi']) ? 1 : $record['multi'];

            $adding_predicted_count = $count + $multiple;

            if (self::$_maxVoteNumber && self::$_maxVoteNumber < ($this->countVotes() + $adding_predicted_count)) :
                throw new CondorcetException(16, self::$_maxParseIteration);
            endif;

            if (self::$_maxParseIteration !== null && $adding_predicted_count >= self::$_maxParseIteration) :
                throw new CondorcetException(12, self::$_maxParseIteration);
            endif;

            $newVote = new Vote ($record['vote'], $tags, null, $this);

            $adding[] = ['multiple' => $multiple, 'vote' => $newVote];

            $count += $multiple;
        endforeach;

        $this->_voteFastMode = true;

        foreach ($adding as $oneLine) :
            for ($i = 1 ; $i <= $oneLine['multiple'] ; $i++) :
                if ($i !== $oneLine['multiple']) :
                    $this->addVote(clone $oneLine['vote']);
                else :
                    $this->addVote($oneLine['vote']);
                endif;
            endfor;
        endforeach;

        $this->_voteFastMode = false;

        return $count;
    }

    public function parseVotes (string $input, bool $isFile = false) : int
    {
        $input = CondorcetUtil::prepareParse($input, $isFile);

        $adding = [];
        $count = 0;

        foreach ($input as $line) :
            // Empty Line
            if (empty($line)) :
                continue;
            endif;

            // Multiples
            $multiple = VoteUtil::parseAnalysingOneLine(mb_strpos($line, '*'),$line);

            // Vote Weight
            $weight = VoteUtil::parseAnalysingOneLine(mb_strpos($line, '^'),$line);

            // Tags + vote
            if (mb_strpos($line, '||') !== false) :
                $data = explode('||', $line);

                $vote = $data[1];
                $tags = $data[0];
            // Vote without tags
            else :
                $vote = $line;
                $tags = null;
            endif;

            $adding_predicted_count = $count + $multiple;

            if (self::$_maxVoteNumber && self::$_maxVoteNumber < ($this->countVotes() + $adding_predicted_count)) :
                throw new CondorcetException(16, (string) self::$_maxParseIteration);
            endif;

            if (self::$_maxParseIteration !== null && $adding_predicted_count >= self::$_maxParseIteration) :
                throw new CondorcetException(12, (string) self::$_maxParseIteration);
            endif;

            $newVote = new Vote ($vote, $tags, null, $this);
            $newVote->setWeight($weight);

            $adding[] = ['multiple' => $multiple, 'vote' => $newVote];

            $count += $multiple;
        endforeach;

        $this->_voteFastMode = true;

        foreach ($adding as $oneLine) :
            for ($i = 1 ; $i <= $oneLine['multiple'] ; $i++) :
                if ($i !== $oneLine['multiple']) :
                    $this->addVote(clone $oneLine['vote']);
                else :
                    $this->addVote($oneLine['vote']);
                endif;
            endfor;
        endforeach;

        $this->_voteFastMode = false;

        return $count;
    }

}