Condorcet\Condorcet

Complexity

Total Complexity

36

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

95.24%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getAuthMethods()	0	11	2
A	getDefaultMethod()	0	3	1
B	testMethod()	0	18	6
C	format()	0	32	12
A	getVersion()	0	11	2
B	isAuthMethod()	0	22	6
A	addMethod()	0	16	4
A	setDefaultMethod()	0	9	3

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 32 and the first side effect is on line 16.

/*
    Condorcet PHP Class, with Schulze Methods and others !

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

namespace Condorcet;

use Condorcet\CondorcetException;
use Condorcet\Result;

// Registering native Condorcet Methods implementation
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\Copeland');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\DodgsonQuick');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\DodgsonTidemanApproximation');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\KemenyYoung');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\MinimaxWinning');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\MinimaxMargin');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\MinimaxOpposition');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\RankedPairsMargin');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\RankedPairsWinning');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\SchulzeWinning');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\SchulzeMargin');
Condorcet::addMethod(__NAMESPACE__.'\\Algo\\Methods\\SchulzeRatio');

// Set the default Condorcet Class algorithm
Condorcet::setDefaultMethod('Schulze');

abstract class Condorcet
{

/////////// CONSTANTS ///////////
    public const VERSION = '1.5.0';

    public const CONDORCET_BASIC_CLASS = __NAMESPACE__.'\\Algo\\Methods\\CondorcetBasic';

    protected static $_defaultMethod = null;
    protected static $_authMethods = [ self::CONDORCET_BASIC_CLASS => (__NAMESPACE__.'\\Algo\\Methods\\CondorcetBasic')::METHOD_NAME ];


/////////// STATICS METHODS ///////////

    // Return library version numer
    public static function getVersion (string $options = 'FULL') : string
    {
        switch ($options) :
            case 'MAJOR':
                $version = explode('.', self::VERSION);
                return $version[0].'.'.$version[1];

            default:
                return self::VERSION;
        endswitch;
    }

    // Return an array with auth methods
    public static function getAuthMethods (bool $basic = false) : array
    {
        $auth = self::$_authMethods;

        // Don't show Natural Condorcet
        if (!$basic) :
            unset($auth[self::CONDORCET_BASIC_CLASS]);
        endif;

        return array_column($auth,0);
    }


    // Return the Class default method
    public static function getDefaultMethod () {
        return self::$_defaultMethod;
    }


    // Check if the method is supported
    public static function isAuthMethod (string $method)
    {
        $auth = self::$_authMethods;

        if (empty($method)) :
            throw new CondorcetException (8);
        endif;

        if ( isset($auth[$method]) ) :
            return $method;
        else : // Alias
            foreach ($auth as $class => &$alias) :
                foreach ($alias as &$entry) :
                    if ( strcasecmp($method,$entry) === 0 ) :
                        return $class;
                    endif;
                endforeach;
            endforeach;
        endif;

        return false;
    }


    // Add algos
    public static function addMethod (string $algos) : bool
    {
        // Check algos
        if ( self::isAuthMethod($algos) || !self::testMethod($algos) ) :
            return false;
        endif;

        // Adding algo
        self::$_authMethods[$algos] = $algos::METHOD_NAME;

        if (self::getDefaultMethod() === null) :
            self::setDefaultMethod($algos);
        endif;

        return true;
    }


        // Check if the class Algo. exist and ready to be used
        protected static function testMethod (string $method) : bool
        {
            if ( !class_exists($method) ) :             
                throw new CondorcetException(9);
            endif;

            if ( !is_subclass_of($method, __NAMESPACE__.'\\Algo\\MethodInterface') || !is_subclass_of($method,__NAMESPACE__.'\\Algo\\Method') ) :

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if __NAMESPACE__ . '\\Algo\\MethodInterface' can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if __NAMESPACE__ . '\\Algo\\Method' can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

                throw new CondorcetException(10);
            endif;

            foreach ($method::METHOD_NAME as $alias) :
                if (self::isAuthMethod($alias)) :
                    throw new CondorcetException(25);
                endif;
            endforeach;

            return true;
        }


    // Change default method for this class.
    public static function setDefaultMethod (string $method) : bool
    {       
        if ( ($method = self::isAuthMethod($method)) && $method !== self::CONDORCET_BASIC_CLASS ) :
            self::$_defaultMethod = $method;
            return true;
        else :
            return false;
        endif;
    }

    // Simplify Condorcet Var_Dump. Transform object to String.
    public static function format ($input, bool $convertObject = true)
    {
        if (is_object($input)) :
            
            $r = $input;

            if ($convertObject) :
                if ($input instanceof Candidate) :
                    $r = (string) $input;
                elseif ($input instanceof Vote) :
                    $r = $input->getRanking();
                elseif ($input instanceof Result) :
                    $r = $input->getResultAsArray(true);
                endif;
            endif;

        elseif (!is_array($input)) :
            $r = $input;
        else :
            foreach ($input as $key => $line) :
                $input[$key] = self::format($line,$convertObject);
            endforeach;

            if (count($input) === 1 && is_int(key($input)) && (!is_array(reset($input)) || count(reset($input)) === 1)):
                $r = reset($input);
            else:
                $r = $input;
            endif;
        endif;
        
        return $r;
    }
}