Result::offsetUnset() - Code Metrics - Inspection of "Add some tests" - julien-boudry/Condorcet - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2a8e0f...9ee175 )

by Boudry

created 2018-01-12 18:26 UTC

Result::offsetUnset() A

↳ Parent: Result

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php
/*
    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\CondorcetVersion;
use Condorcet\Election;
use Condorcet\Util;
use Condorcet\Vote;


class Result implements \ArrayAccess, \Countable, \Iterator 
{
    use CondorcetVersion;

    // Implement Iterator

    function rewind() :void {

        reset($this->_UserResult);
    }

    function current () {

        return current($this->_UserResult);
    }

    function key () : int {

        return key($this->_UserResult);
    }

    function next () : void {

        next($this->_UserResult);
    }

    function valid () : bool {

        return (key($this->_UserResult) === null) ? false : true;
    }

    // Implement ArrayAccess

    public function offsetSet ($offset, $value) : void {
        throw new CondorcetException (0,"Can't change a result");
    }

    public function offsetExists ($offset) : bool {
        return isset($this->_UserResult[$offset]);
    }

    public function offsetUnset ($offset) : void {
        throw new CondorcetException (0,"Can't change a result");
    }

    public function offsetGet ($offset) {
        return $this->_UserResult[$offset] ?? null;
    }

    // Implement Countable

    public function count () : int {
        return count($this->_UserResult);
    }


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

    protected $_Result;
    protected $_UserResult;
    protected $_stringResult;
    protected $_CondorcetWinner;
    protected $_CondorcetLoser;

    protected $_Stats;

    protected $_warning = [];

    protected $_BuildTimeStamp;
    protected $_fromMethod;
    protected $_byClass;
    protected $_ElectionCondorcetVersion;


    public function __construct (string $fromMethod, string $byClass, Election $election, array $result, $stats)
    {
        $this->_Result = $result;
        $this->_UserResult = $this->makeUserResult($election);
        $this->_stringResult = $this->getResultAsArray(true);
        $this->_Stats = $stats;
        $this->_fromMethod = $fromMethod;
        $this->_byClass = $byClass;
        $this->_ElectionCondorcetVersion = $election->getObjectVersion();
        $this->_CondorcetWinner = $election->getWinner();
        $this->_CondorcetLoser = $election->getLoser();
        $this->_BuildTimeStamp = microtime(true);
    }


/////////// Get Result ///////////

    public function getResultAsArray (bool $convertToString = false) : array
    {
        $r = $this->_UserResult;

        foreach ($r as &$rank) :
            if (count($rank) === 1) :
                $rank = ($convertToString) ? (string) $rank[0] : $rank[0];
            elseif ($convertToString) :
                foreach ($rank as &$subRank) :
                    $subRank = (string) $subRank;
                endforeach;
            endif;
        endforeach;

        return $r;
    }

    public function getResultAsString ()
    {
        return Vote::getRankingAsString($this->getResultAsArray(true));
    }

    public function getOriginalArrayWithString () : array
    {
        return $this->_stringResult;
    }

    public function getResultAsInternalKey () : array
    {
        return $this->_Result;
    }

    public function getStats () {
        return $this->_Stats;
    }

    public function getWinner () {
        return Util::format($this[1],false);
    }

    public function getLoser () {
        return Util::format($this[count($this)],false);
    }

    public function getCondorcetWinner () {
        return $this->_CondorcetWinner;
    }

    public function getCondorcetLoser () {
        return $this->_CondorcetLoser;
    }

    protected function makeUserResult (Election $election) : array
    {
        $userResult = [];

        foreach ( $this->_Result as $key => $value ) :
            if (is_array($value)) :
                foreach ($value as $candidate_key) :
                    $userResult[$key][] = $election->getCandidateId($candidate_key);
                endforeach;
            elseif (is_null($value)) :
                $userResult[$key] = null;
            else :
                $userResult[$key][] = $election->getCandidateId($value);
            endif;
        endforeach;

        foreach ( $userResult as $key => $value ) :
            if (is_null($value)) :
                $userResult[$key] = null;
            endif;
        endforeach;

        return $userResult;
    }


/////////// Get & Set MetaData ///////////

    public function addWarning (int $type, string $msg = null) : bool
    {
        $this->_warning[] = ['type' => $type, 'msg' => $msg];

        return true;
    }

    public function getWarning ($type = null) : array
    {
        if ($type === null) :
            return $this->_warning;
        else :
            $r = [];

            foreach ($this->_warning as $oneWarning) :
                if ($oneWarning['type'] === (int) $type) :
                    $r[] = $oneWarning;
                endif;
            endforeach;

            return $r;
        endif;
    }

    public function getClassGenerator () : string {
        return $this->_byClass;
    }

    public function getMethod () : string {
        return $this->_fromMethod;
    }

    public function getBuildTimeStamp () : float {
        return (float) $this->_BuildTimeStamp;
    }

    public function getCondorcetElectionGeneratorVersion () : string {
        return $this->_ElectionCondorcetVersion;
    }

}


1		<?php
2		/*
3		Condorcet PHP Class, with Schulze Methods and others !
4
5		By Julien Boudry - MIT LICENSE (Please read LICENSE.txt)
6		https://github.com/julien-boudry/Condorcet
7		*/
8		declare(strict_types=1);
9
10		namespace Condorcet;
11
12		use Condorcet\CondorcetException;
13		use Condorcet\CondorcetVersion;
14		use Condorcet\Election;
15		use Condorcet\Util;
16		use Condorcet\Vote;
17
18
19		class Result implements \ArrayAccess, \Countable, \Iterator
20		{
21		use CondorcetVersion;
22
23		// Implement Iterator
24
25	1	function rewind() :void {
		0 ignored issues – show Best Practice introduced 2018-01-08 14:18 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
26	1	reset($this->_UserResult);
27	1	}
28
29	1	function current () {
		0 ignored issues – show Best Practice introduced 2018-01-08 14:18 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
30	1	return current($this->_UserResult);
31		}
32
33	1	function key () : int {
		0 ignored issues – show Best Practice introduced 2018-01-08 14:18 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
34	1	return key($this->_UserResult);
35		}
36
37	1	function next () : void {
		0 ignored issues – show Best Practice introduced 2018-01-08 14:18 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
38	1	next($this->_UserResult);
39	1	}
40
41	1	function valid () : bool {
		0 ignored issues – show Best Practice introduced 2018-01-08 14:18 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
42	1	return (key($this->_UserResult) === null) ? false : true;
43		}
44
45		// Implement ArrayAccess
46
47	1	public function offsetSet ($offset, $value) : void {
48	1	throw new CondorcetException (0,"Can't change a result");
49		}
50
51		public function offsetExists ($offset) : bool {
52		return isset($this->_UserResult[$offset]);
53		}
54
55	1	public function offsetUnset ($offset) : void {
56	1	throw new CondorcetException (0,"Can't change a result");
57		}
58
59	47	public function offsetGet ($offset) {
60	47	return $this->_UserResult[$offset] ?? null;
61		}
62
63		// Implement Countable
64
65	2	public function count () : int {
66	2	return count($this->_UserResult);
67		}
68
69
70		/////////// CONSTRUCTOR ///////////
71
72		protected $_Result;
73		protected $_UserResult;
74		protected $_stringResult;
75		protected $_CondorcetWinner;
76		protected $_CondorcetLoser;
77
78		protected $_Stats;
79
80		protected $_warning = [];
81
82		protected $_BuildTimeStamp;
83		protected $_fromMethod;
84		protected $_byClass;
85		protected $_ElectionCondorcetVersion;
86
87
88	66	public function __construct (string $fromMethod, string $byClass, Election $election, array $result, $stats)
89		{
90	66	$this->_Result = $result;
91	66	$this->_UserResult = $this->makeUserResult($election);
92	66	$this->_stringResult = $this->getResultAsArray(true);
93	66	$this->_Stats = $stats;
94	66	$this->_fromMethod = $fromMethod;
95	66	$this->_byClass = $byClass;
96	66	$this->_ElectionCondorcetVersion = $election->getObjectVersion();
97	66	$this->_CondorcetWinner = $election->getWinner();
98	66	$this->_CondorcetLoser = $election->getLoser();
99	66	$this->_BuildTimeStamp = microtime(true);
100	66	}
101
102
103		/////////// Get Result ///////////
104
105	66	public function getResultAsArray (bool $convertToString = false) : array
106		{
107	66	$r = $this->_UserResult;
108
109	66	foreach ($r as &$rank) :
110	66	if (count($rank) === 1) :
111	63	$rank = ($convertToString) ? (string) $rank[0] : $rank[0];
112	24	elseif ($convertToString) :
113	24	foreach ($rank as &$subRank) :
114	66	$subRank = (string) $subRank;
115		endforeach;
116		endif;
117		endforeach;
118
119	66	return $r;
120		}
121
122	2	public function getResultAsString ()
123		{
124	2	return Vote::getRankingAsString($this->getResultAsArray(true));
125		}
126
127	1	public function getOriginalArrayWithString () : array
128		{
129	1	return $this->_stringResult;
130		}
131
132		public function getResultAsInternalKey () : array
133		{
134		return $this->_Result;
135		}
136
137	11	public function getStats () {
138	11	return $this->_Stats;
139		}
140
141	47	public function getWinner () {
142	47	return Util::format($this[1],false);
143		}
144
145	2	public function getLoser () {
146	2	return Util::format($this[count($this)],false);
147		}
148
149		public function getCondorcetWinner () {
150		return $this->_CondorcetWinner;
151		}
152
153		public function getCondorcetLoser () {
154		return $this->_CondorcetLoser;
155		}
156
157	66	protected function makeUserResult (Election $election) : array
158		{
159	66	$userResult = [];
160
161	66	foreach ( $this->_Result as $key => $value ) :
162	66	if (is_array($value)) :
163	63	foreach ($value as $candidate_key) :
164	63	$userResult[$key][] = $election->getCandidateId($candidate_key);
165		endforeach;
166	5	elseif (is_null($value)) :
167		$userResult[$key] = null;
168		else :
169	66	$userResult[$key][] = $election->getCandidateId($value);
170		endif;
171		endforeach;
172
173	66	foreach ( $userResult as $key => $value ) :
174	66	if (is_null($value)) :
175	66	$userResult[$key] = null;
176		endif;
177		endforeach;
178
179	66	return $userResult;
180		}
181
182
183		/////////// Get & Set MetaData ///////////
184
185	1	public function addWarning (int $type, string $msg = null) : bool
186		{
187	1	$this->_warning[] = ['type' => $type, 'msg' => $msg];
188
189	1	return true;
190		}
191
192	2	public function getWarning ($type = null) : array
193		{
194	2	if ($type === null) :
195		return $this->_warning;
196		else :
197	2	$r = [];
198
199	2	foreach ($this->_warning as $oneWarning) :
200	1	if ($oneWarning['type'] === (int) $type) :
201	1	$r[] = $oneWarning;
202		endif;
203		endforeach;
204
205	2	return $r;
206		endif;
207		}
208
209	1	public function getClassGenerator () : string {
210	1	return $this->_byClass;
211		}
212
213	1	public function getMethod () : string {
214	1	return $this->_fromMethod;
215		}
216
217	1	public function getBuildTimeStamp () : float {
218	1	return (float) $this->_BuildTimeStamp;
219		}
220
221	1	public function getCondorcetElectionGeneratorVersion () : string {
222	1	return $this->_ElectionCondorcetVersion;
223		}
224
225		}
226

julien-boudry / Condorcet

Push — master ( 2a8e0f...9ee175 )

Result::offsetUnset() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like