Argument::any() - Code Metrics - Inspection of "Introduce Argument::withAllEntries() and Argument:..." - phpspec/prophecy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#417)

by Garry

created 2018-10-17 05:51 UTC

Argument::any() A

↳ Parent: Argument

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

/*
 * This file is part of the Prophecy.
 * (c) Konstantin Kudryashov <[email protected]>
 *     Marcello Duarte <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Prophecy;

use Prophecy\Argument\Token;

/**
 * Argument tokens shortcuts.
 *
 * @author Konstantin Kudryashov <[email protected]>
 */
class Argument
{
    /**
     * Checks that argument is exact value or object.
     *
     * @param mixed $value
     *
     * @return Token\ExactValueToken
     */
    public static function exact($value)
    {
        return new Token\ExactValueToken($value);
    }

    /**
     * Checks that argument is of specific type or instance of specific class.
     *
     * @param string $type Type name (`integer`, `string`) or full class name
     *
     * @return Token\TypeToken
     */
    public static function type($type)
    {
        return new Token\TypeToken($type);
    }

    /**
     * Checks that argument object has specific state.
     *
     * @param string $methodName
     * @param mixed  $value
     *
     * @return Token\ObjectStateToken
     */
    public static function which($methodName, $value)
    {
        return new Token\ObjectStateToken($methodName, $value);
    }

    /**
     * Checks that argument matches provided callback.
     *
     * @param callable $callback
     *
     * @return Token\CallbackToken
     */
    public static function that($callback)
    {
        return new Token\CallbackToken($callback);
    }

    /**
     * Matches any single value.
     *
     * @return Token\AnyValueToken
     */
    public static function any()
    {
        return new Token\AnyValueToken;
    }

    /**
     * Matches all values to the rest of the signature.
     *
     * @return Token\AnyValuesToken
     */
    public static function cetera()
    {
        return new Token\AnyValuesToken;
    }

    /**
     * Checks that argument matches all tokens
     *
     * @param mixed ... a list of tokens
     *
     * @return Token\LogicalAndToken
     */
    public static function allOf()
    {
        return new Token\LogicalAndToken(func_get_args());
    }

    /**
     * Checks that argument array or countable object has exact number of elements.
     *
     * @param integer $value array elements count
     *
     * @return Token\ArrayCountToken
     */
    public static function size($value)
    {
        return new Token\ArrayCountToken($value);
    }

    /**
     * Checks that argument array contains (key, value) pair
     *
     * @param mixed $key   exact value or token
     * @param mixed $value exact value or token
     *
     * @return Token\ArrayEntryToken
     */
    public static function withEntry($key, $value)
    {
        return new Token\ArrayEntryToken($key, $value);
    }

    /**
     * Checks that arguments array entries all match value
     *
     * @param mixed $value
     *
     * @return Token\ArrayEveryEntryToken
     */
    public static function withEveryEntry($value)
    {
        return new Token\ArrayEveryEntryToken($value);
    }

    /**
     * Checks that argument array contains value
     *
     * @param mixed $value
     *
     * @return Token\ArrayEntryToken
     */
    public static function containing($value)
    {
        return new Token\ArrayEntryToken(self::any(), $value);
    }

    /**
     * Checks that argument array has key
     *
     * @param mixed $key exact value or token
     *
     * @return Token\ArrayEntryToken
     */
    public static function withKey($key)
    {
        return new Token\ArrayEntryToken($key, self::any());
    }

    /**
     * Checks that argument does not match the value|token.
     *
     * @param mixed $value either exact value or argument token
     *
     * @return Token\LogicalNotToken
     */
    public static function not($value)
    {
        return new Token\LogicalNotToken($value);
    }

    /**
     * @param string $value
     *
     * @return Token\StringContainsToken
     */
    public static function containingString($value)
    {
        return new Token\StringContainsToken($value);
    }

    /**
     * Checks that argument is identical value.
     *
     * @param mixed $value
     *
     * @return Token\IdenticalValueToken
     */
    public static function is($value)
    {
        return new Token\IdenticalValueToken($value);
    }

    /**
     * Check that argument is same value when rounding to the
     * given precision.
     *
     * @param float $value
     * @param float $precision
     *
     * @return Token\ApproximateValueToken
     */
    public static function approximate($value, $precision = 0)
    {
        return new Token\ApproximateValueToken($value, $precision);
    }

    /**
     * Check that argument contains all (key, value) pairs
     *
     * @param mixed $values
     *
     * @return Token\LogicalAndToken
     */
    public static function withAllEntries($values)
    {
        $entries = array();
        foreach ($values as $key => $value) {
            $entries[] = new Token\ArrayEntryToken($key, $value);
        }

        return new Token\LogicalAndToken($entries);
    }

    /**
     * Check that argument contains all of the values
     *
     * @param mixed ... a list of values
     *
     * @return Token\LogicalAndToken
     */
    public static function containingAllOf()
    {
        $entries = array();
        foreach (func_get_args() as $value) {
            $entries[] = new Token\ArrayEntryToken(self::any(), $value);
        }

        return new Token\LogicalAndToken($entries);
    }
}


1			<?php
2
3			/*
4			* This file is part of the Prophecy.
5			* (c) Konstantin Kudryashov <[email protected]>
6			* Marcello Duarte <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Prophecy;
13
14			use Prophecy\Argument\Token;
15
16			/**
17			* Argument tokens shortcuts.
18			*
19			* @author Konstantin Kudryashov <[email protected]>
20			*/
21			class Argument
22			{
23			/**
24			* Checks that argument is exact value or object.
25			*
26			* @param mixed $value
27			*
28			* @return Token\ExactValueToken
29			*/
30			public static function exact($value)
31			{
32			return new Token\ExactValueToken($value);
33			}
34
35			/**
36			* Checks that argument is of specific type or instance of specific class.
37			*
38			* @param string $type Type name (`integer`, `string`) or full class name
39			*
40			* @return Token\TypeToken
41			*/
42			public static function type($type)
43			{
44			return new Token\TypeToken($type);
45			}
46
47			/**
48			* Checks that argument object has specific state.
49			*
50			* @param string $methodName
51			* @param mixed $value
52			*
53			* @return Token\ObjectStateToken
54			*/
55			public static function which($methodName, $value)
56			{
57			return new Token\ObjectStateToken($methodName, $value);
58			}
59
60			/**
61			* Checks that argument matches provided callback.
62			*
63			* @param callable $callback
64			*
65			* @return Token\CallbackToken
66			*/
67			public static function that($callback)
68			{
69			return new Token\CallbackToken($callback);
70			}
71
72			/**
73			* Matches any single value.
74			*
75			* @return Token\AnyValueToken
76			*/
77			public static function any()
78			{
79			return new Token\AnyValueToken;
80			}
81
82			/**
83			* Matches all values to the rest of the signature.
84			*
85			* @return Token\AnyValuesToken
86			*/
87			public static function cetera()
88			{
89			return new Token\AnyValuesToken;
90			}
91
92			/**
93			* Checks that argument matches all tokens
94			*
95			* @param mixed ... a list of tokens
96			*
97			* @return Token\LogicalAndToken
98			*/
99			public static function allOf()
100			{
101			return new Token\LogicalAndToken(func_get_args());
102			}
103
104			/**
105			* Checks that argument array or countable object has exact number of elements.
106			*
107			* @param integer $value array elements count
108			*
109			* @return Token\ArrayCountToken
110			*/
111			public static function size($value)
112			{
113			return new Token\ArrayCountToken($value);
114			}
115
116			/**
117			* Checks that argument array contains (key, value) pair
118			*
119			* @param mixed $key exact value or token
120			* @param mixed $value exact value or token
121			*
122			* @return Token\ArrayEntryToken
123			*/
124			public static function withEntry($key, $value)
125			{
126			return new Token\ArrayEntryToken($key, $value);
127			}
128
129			/**
130			* Checks that arguments array entries all match value
131			*
132			* @param mixed $value
133			*
134			* @return Token\ArrayEveryEntryToken
135			*/
136			public static function withEveryEntry($value)
137			{
138			return new Token\ArrayEveryEntryToken($value);
139			}
140
141			/**
142			* Checks that argument array contains value
143			*
144			* @param mixed $value
145			*
146			* @return Token\ArrayEntryToken
147			*/
148			public static function containing($value)
149			{
150			return new Token\ArrayEntryToken(self::any(), $value);
151			}
152
153			/**
154			* Checks that argument array has key
155			*
156			* @param mixed $key exact value or token
157			*
158			* @return Token\ArrayEntryToken
159			*/
160			public static function withKey($key)
161			{
162			return new Token\ArrayEntryToken($key, self::any());
163			}
164
165			/**
166			* Checks that argument does not match the value\|token.
167			*
168			* @param mixed $value either exact value or argument token
169			*
170			* @return Token\LogicalNotToken
171			*/
172			public static function not($value)
173			{
174			return new Token\LogicalNotToken($value);
175			}
176
177			/**
178			* @param string $value
179			*
180			* @return Token\StringContainsToken
181			*/
182			public static function containingString($value)
183			{
184			return new Token\StringContainsToken($value);
185			}
186
187			/**
188			* Checks that argument is identical value.
189			*
190			* @param mixed $value
191			*
192			* @return Token\IdenticalValueToken
193			*/
194			public static function is($value)
195			{
196			return new Token\IdenticalValueToken($value);
197			}
198
199			/**
200			* Check that argument is same value when rounding to the
201			* given precision.
202			*
203			* @param float $value
204			* @param float $precision
205			*
206			* @return Token\ApproximateValueToken
207			*/
208			public static function approximate($value, $precision = 0)
209			{
210			return new Token\ApproximateValueToken($value, $precision);
211			}
212
213			/**
214			* Check that argument contains all (key, value) pairs
215			*
216			* @param mixed $values
217			*
218			* @return Token\LogicalAndToken
219			*/
220			public static function withAllEntries($values)
221			{
222			$entries = array();
223			foreach ($values as $key => $value) {
224			$entries[] = new Token\ArrayEntryToken($key, $value);
225			}
226
227			return new Token\LogicalAndToken($entries);
228			}
229
230			/**
231			* Check that argument contains all of the values
232			*
233			* @param mixed ... a list of values
234			*
235			* @return Token\LogicalAndToken
236			*/
237			public static function containingAllOf()
238			{
239			$entries = array();
240			foreach (func_get_args() as $value) {
241			$entries[] = new Token\ArrayEntryToken(self::any(), $value);
242			}
243
244			return new Token\LogicalAndToken($entries);
245			}
246			}
247

phpspec / prophecy

Pull Request — master (#417)

Argument::any() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like