Spec::selectHiddenAs() - Code Metrics - Inspection of "Merge pull request #172 from peter-gribanov/select" - Happyr/Doctrine-Specification - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.0 ( 75b22b...f155d9 )

by Peter

created 2019-04-22 08:12 UTC

Spec::selectHiddenAs() A

↳ Parent: Spec

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	2

<?php

namespace Happyr\DoctrineSpecification;

use Happyr\DoctrineSpecification\Filter\Comparison;
use Happyr\DoctrineSpecification\Filter\Filter;
use Happyr\DoctrineSpecification\Filter\In;
use Happyr\DoctrineSpecification\Filter\InstanceOfX;
use Happyr\DoctrineSpecification\Filter\IsNotNull;
use Happyr\DoctrineSpecification\Filter\IsNull;
use Happyr\DoctrineSpecification\Filter\Like;
use Happyr\DoctrineSpecification\Logic\AndX;
use Happyr\DoctrineSpecification\Logic\Not;
use Happyr\DoctrineSpecification\Logic\OrX;
use Happyr\DoctrineSpecification\Operand\Alias;
use Happyr\DoctrineSpecification\Operand\Field;
use Happyr\DoctrineSpecification\Operand\LikePattern;
use Happyr\DoctrineSpecification\Operand\Operand;
use Happyr\DoctrineSpecification\Operand\Value;
use Happyr\DoctrineSpecification\Operand\Values;
use Happyr\DoctrineSpecification\Query\AddSelect;
use Happyr\DoctrineSpecification\Query\GroupBy;
use Happyr\DoctrineSpecification\Query\InnerJoin;
use Happyr\DoctrineSpecification\Query\Join;
use Happyr\DoctrineSpecification\Query\LeftJoin;
use Happyr\DoctrineSpecification\Query\Limit;
use Happyr\DoctrineSpecification\Query\Offset;
use Happyr\DoctrineSpecification\Query\OrderBy;
use Happyr\DoctrineSpecification\Query\QueryModifier;
use Happyr\DoctrineSpecification\Query\Select;
use Happyr\DoctrineSpecification\Query\Selection\SelectAs;
use Happyr\DoctrineSpecification\Query\Selection\SelectEntity;
use Happyr\DoctrineSpecification\Query\Selection\SelectHiddenAs;
use Happyr\DoctrineSpecification\Query\Slice;
use Happyr\DoctrineSpecification\Result\AsArray;
use Happyr\DoctrineSpecification\Result\AsSingleScalar;
use Happyr\DoctrineSpecification\Result\Cache;
use Happyr\DoctrineSpecification\Result\RoundDateTime;
use Happyr\DoctrineSpecification\Specification\CountOf;
use Happyr\DoctrineSpecification\Specification\Having;

/**
 * Factory class for the specifications.
 */
class Spec
{
    /*
     * Logic
     */

    /**
     * @return AndX
     */
    public static function andX()
    {
        $args = func_get_args();
        $reflection = new \ReflectionClass('Happyr\DoctrineSpecification\Logic\AndX');

        return $reflection->newInstanceArgs($args);
    }

    /**
     * @return OrX
     */
    public static function orX()
    {
        $args = func_get_args();
        $reflection = new \ReflectionClass('Happyr\DoctrineSpecification\Logic\OrX');

        return $reflection->newInstanceArgs($args);
    }

    /**
     * @param Filter $spec
     *
     * @return Not
     */
    public static function not(Filter $spec)
    {
        return new Not($spec);
    }

    /*
     * Query modifier
     */

    /**
     * @param string $field
     * @param string $newAlias
     * @param string $dqlAlias
     *
     * @return Join
     */
    public static function join($field, $newAlias, $dqlAlias = null)
    {
        return new Join($field, $newAlias, $dqlAlias);
    }

    /**
     * @param string $field
     * @param string $newAlias
     * @param string $dqlAlias
     *
     * @return LeftJoin
     */
    public static function leftJoin($field, $newAlias, $dqlAlias = null)
    {
        return new LeftJoin($field, $newAlias, $dqlAlias);
    }

    /**
     * @param string $field
     * @param string $newAlias
     * @param string $dqlAlias
     *
     * @return InnerJoin
     */
    public static function innerJoin($field, $newAlias, $dqlAlias = null)
    {
        return new InnerJoin($field, $newAlias, $dqlAlias);
    }

    /**
     * @param int $count
     *
     * @return Limit
     */
    public static function limit($count)
    {
        return new Limit($count);
    }

    /**
     * @param int $count
     *
     * @return Offset
     */
    public static function offset($count)
    {
        return new Offset($count);
    }

    /**
     * @param int $sliceSize
     * @param int $sliceNumber
     *
     * @return Slice
     */
    public static function slice($sliceSize, $sliceNumber = 0)
    {
        return new Slice($sliceSize, $sliceNumber);
    }

    /**
     * @param string      $field
     * @param string      $order
     * @param string|null $dqlAlias
     *
     * @return OrderBy
     */
    public static function orderBy($field, $order = 'ASC', $dqlAlias = null)
    {
        return new OrderBy($field, $order, $dqlAlias);
    }

    /**
     * @param string $field
     * @param string $dqlAlias
     *
     * @return GroupBy
     */
    public static function groupBy($field, $dqlAlias = null)
    {
        return new GroupBy($field, $dqlAlias);
    }

    /*
     * Selection
     */

    /**
     * @param mixed $field
     *
     * @return Select
     */
    public static function select($field)

    {
        return new Select(func_get_args());
    }

    /**
     * @param mixed $field
     *
     * @return AddSelect
     */
    public static function addSelect($field)

    {
        return new AddSelect(func_get_args());
    }

    /**
     * @param string $dqlAlias
     *
     * @return SelectEntity
     */
    public static function selectEntity($dqlAlias)
    {
        return new SelectEntity($dqlAlias);
    }

    /**
     * @param Filter|Operand|string $expression
     * @param string                $alias
     *
     * @return SelectAs
     */
    public static function selectAs($expression, $alias)
    {
        return new SelectAs($expression, $alias);
    }

    /**
     * @param Filter|Operand|string $expression
     * @param string                $alias
     *
     * @return SelectHiddenAs
     */
    public static function selectHiddenAs($expression, $alias)
    {
        return new SelectHiddenAs($expression, $alias);
    }

    /*
     * Result modifier
     */

    /**
     * @return AsArray
     */
    public static function asArray()
    {
        return new AsArray();
    }

    /**
     * @return AsSingleScalar
     */
    public static function asSingleScalar()
    {
        return new AsSingleScalar();
    }

    /**
     * @param int $cacheLifetime How many seconds the cached entry is valid
     *
     * @return Cache
     */
    public static function cache($cacheLifetime)
    {
        return new Cache($cacheLifetime);
    }

    /**
     * @param int $roundSeconds How may seconds to round time
     *
     * @return RoundDateTime
     */
    public static function roundDateTimeParams($roundSeconds)
    {
        return new RoundDateTime($roundSeconds);
    }

    /*
     * Filters
     */

    /**
     * @param Operand|string $field
     * @param string|null    $dqlAlias
     *
     * @return IsNull
     */
    public static function isNull($field, $dqlAlias = null)
    {
        return new IsNull($field, $dqlAlias);
    }

    /**
     * @param Operand|string $field
     * @param string|null    $dqlAlias
     *
     * @return IsNotNull
     */
    public static function isNotNull($field, $dqlAlias = null)
    {
        return new IsNotNull($field, $dqlAlias);
    }

    /**
     * Make sure the $field has a value equals to $value.
     *
     * @param string $field
     * @param mixed  $value
     * @param string $dqlAlias
     *
     * @return In
     */
    public static function in($field, $value, $dqlAlias = null)
    {
        return new In($field, $value, $dqlAlias);
    }

    /**
     * @param string $field
     * @param mixed  $value
     * @param string $dqlAlias
     *
     * @return Not
     */
    public static function notIn($field, $value, $dqlAlias = null)
    {
        return new Not(new In($field, $value, $dqlAlias));
    }

    /**
     * @param Operand|string $field
     * @param Operand|mixed  $value
     * @param string|null    $dqlAlias
     *
     * @return Comparison
     */
    public static function eq($field, $value, $dqlAlias = null)
    {
        return new Comparison(Comparison::EQ, $field, $value, $dqlAlias);
    }

    /**
     * @param Operand|string $field
     * @param Operand|mixed  $value
     * @param string|null    $dqlAlias
     *
     * @return Comparison
     */
    public static function neq($field, $value, $dqlAlias = null)
    {
        return new Comparison(Comparison::NEQ, $field, $value, $dqlAlias);
    }

    /**
     * @param Operand|string $field
     * @param Operand|mixed  $value
     * @param string|null    $dqlAlias
     *
     * @return Comparison
     */
    public static function lt($field, $value, $dqlAlias = null)
    {
        return new Comparison(Comparison::LT, $field, $value, $dqlAlias);
    }

    /**
     * @param Operand|string $field
     * @param Operand|mixed  $value
     * @param string|null    $dqlAlias
     *
     * @return Comparison
     */
    public static function lte($field, $value, $dqlAlias = null)
    {
        return new Comparison(Comparison::LTE, $field, $value, $dqlAlias);
    }

    /**
     * @param Operand|string $field
     * @param Operand|mixed  $value
     * @param string|null    $dqlAlias
     *
     * @return Comparison
     */
    public static function gt($field, $value, $dqlAlias = null)
    {
        return new Comparison(Comparison::GT, $field, $value, $dqlAlias);
    }

    /**
     * @param Operand|string $field
     * @param Operand|mixed  $value
     * @param string|null    $dqlAlias
     *
     * @return Comparison
     */
    public static function gte($field, $value, $dqlAlias = null)
    {
        return new Comparison(Comparison::GTE, $field, $value, $dqlAlias);
    }

    /**
     * @param Operand|string $field
     * @param string         $value
     * @param string         $format
     * @param string|null    $dqlAlias
     *
     * @return Like
     */
    public static function like($field, $value, $format = Like::CONTAINS, $dqlAlias = null)
    {
        return new Like($field, $value, $format, $dqlAlias);
    }

    /**
     * @param string      $value
     * @param string|null $dqlAlias
     *
     * @return InstanceOfX
     */
    public static function instanceOfX($value, $dqlAlias = null)
    {
        return new InstanceOfX($value, $dqlAlias);
    }

    /*
     * Specifications
     */

    /**
     * @param Filter|QueryModifier $spec
     *
     * @return CountOf
     */
    public static function countOf($spec)
    {
        return new CountOf($spec);
    }

    /**
     * @param Filter|string $spec
     *
     * @return Having
     */
    public static function having($spec)
    {
        return new Having($spec);
    }

    /*
     * Operands
     */

    /**
     * @param string $fieldName
     *
     * @return Field
     */
    public static function field($fieldName)
    {
        return new Field($fieldName);
    }

    /**
     * @param mixed           $value
     * @param int|string|null $valueType
     *
     * @return Value
     */
    public static function value($value, $valueType = null)
    {
        return new Value($value, $valueType);
    }

    /**
     * @param array           $values
     * @param int|string|null $valueType
     *
     * @return Values
     */
    public static function values($values, $valueType = null)
    {
        return new Values($values, $valueType);
    }

    /**
     * @param string $value
     * @param string $format
     *
     * @return LikePattern
     */
    public static function likePattern($value, $format = LikePattern::CONTAINS)
    {
        return new LikePattern($value, $format);
    }

    /**
     * @param string $alias
     *
     * @return Alias
     */
    public static function alias($alias)
    {
        return new Alias($alias);
    }
}


1			<?php
2
3			namespace Happyr\DoctrineSpecification;
4
5			use Happyr\DoctrineSpecification\Filter\Comparison;
6			use Happyr\DoctrineSpecification\Filter\Filter;
7			use Happyr\DoctrineSpecification\Filter\In;
8			use Happyr\DoctrineSpecification\Filter\InstanceOfX;
9			use Happyr\DoctrineSpecification\Filter\IsNotNull;
10			use Happyr\DoctrineSpecification\Filter\IsNull;
11			use Happyr\DoctrineSpecification\Filter\Like;
12			use Happyr\DoctrineSpecification\Logic\AndX;
13			use Happyr\DoctrineSpecification\Logic\Not;
14			use Happyr\DoctrineSpecification\Logic\OrX;
15			use Happyr\DoctrineSpecification\Operand\Alias;
16			use Happyr\DoctrineSpecification\Operand\Field;
17			use Happyr\DoctrineSpecification\Operand\LikePattern;
18			use Happyr\DoctrineSpecification\Operand\Operand;
19			use Happyr\DoctrineSpecification\Operand\Value;
20			use Happyr\DoctrineSpecification\Operand\Values;
21			use Happyr\DoctrineSpecification\Query\AddSelect;
22			use Happyr\DoctrineSpecification\Query\GroupBy;
23			use Happyr\DoctrineSpecification\Query\InnerJoin;
24			use Happyr\DoctrineSpecification\Query\Join;
25			use Happyr\DoctrineSpecification\Query\LeftJoin;
26			use Happyr\DoctrineSpecification\Query\Limit;
27			use Happyr\DoctrineSpecification\Query\Offset;
28			use Happyr\DoctrineSpecification\Query\OrderBy;
29			use Happyr\DoctrineSpecification\Query\QueryModifier;
30			use Happyr\DoctrineSpecification\Query\Select;
31			use Happyr\DoctrineSpecification\Query\Selection\SelectAs;
32			use Happyr\DoctrineSpecification\Query\Selection\SelectEntity;
33			use Happyr\DoctrineSpecification\Query\Selection\SelectHiddenAs;
34			use Happyr\DoctrineSpecification\Query\Slice;
35			use Happyr\DoctrineSpecification\Result\AsArray;
36			use Happyr\DoctrineSpecification\Result\AsSingleScalar;
37			use Happyr\DoctrineSpecification\Result\Cache;
38			use Happyr\DoctrineSpecification\Result\RoundDateTime;
39			use Happyr\DoctrineSpecification\Specification\CountOf;
40			use Happyr\DoctrineSpecification\Specification\Having;
41
42			/**
43			* Factory class for the specifications.
44			*/
45			class Spec
46			{
47			/*
48			* Logic
49			*/
50
51			/**
52			* @return AndX
53			*/
54			public static function andX()
55			{
56			$args = func_get_args();
57			$reflection = new \ReflectionClass('Happyr\DoctrineSpecification\Logic\AndX');
58
59			return $reflection->newInstanceArgs($args);
60			}
61
62			/**
63			* @return OrX
64			*/
65			public static function orX()
66			{
67			$args = func_get_args();
68			$reflection = new \ReflectionClass('Happyr\DoctrineSpecification\Logic\OrX');
69
70			return $reflection->newInstanceArgs($args);
71			}
72
73			/**
74			* @param Filter $spec
75			*
76			* @return Not
77			*/
78			public static function not(Filter $spec)
79			{
80			return new Not($spec);
81			}
82
83			/*
84			* Query modifier
85			*/
86
87			/**
88			* @param string $field
89			* @param string $newAlias
90			* @param string $dqlAlias
91			*
92			* @return Join
93			*/
94			public static function join($field, $newAlias, $dqlAlias = null)
95			{
96			return new Join($field, $newAlias, $dqlAlias);
97			}
98
99			/**
100			* @param string $field
101			* @param string $newAlias
102			* @param string $dqlAlias
103			*
104			* @return LeftJoin
105			*/
106			public static function leftJoin($field, $newAlias, $dqlAlias = null)
107			{
108			return new LeftJoin($field, $newAlias, $dqlAlias);
109			}
110
111			/**
112			* @param string $field
113			* @param string $newAlias
114			* @param string $dqlAlias
115			*
116			* @return InnerJoin
117			*/
118			public static function innerJoin($field, $newAlias, $dqlAlias = null)
119			{
120			return new InnerJoin($field, $newAlias, $dqlAlias);
121			}
122
123			/**
124			* @param int $count
125			*
126			* @return Limit
127			*/
128			public static function limit($count)
129			{
130			return new Limit($count);
131			}
132
133			/**
134			* @param int $count
135			*
136			* @return Offset
137			*/
138			public static function offset($count)
139			{
140			return new Offset($count);
141			}
142
143			/**
144			* @param int $sliceSize
145			* @param int $sliceNumber
146			*
147			* @return Slice
148			*/
149			public static function slice($sliceSize, $sliceNumber = 0)
150			{
151			return new Slice($sliceSize, $sliceNumber);
152			}
153
154			/**
155			* @param string $field
156			* @param string $order
157			* @param string\|null $dqlAlias
158			*
159			* @return OrderBy
160			*/
161			public static function orderBy($field, $order = 'ASC', $dqlAlias = null)
162			{
163			return new OrderBy($field, $order, $dqlAlias);
164			}
165
166			/**
167			* @param string $field
168			* @param string $dqlAlias
169			*
170			* @return GroupBy
171			*/
172			public static function groupBy($field, $dqlAlias = null)
173			{
174			return new GroupBy($field, $dqlAlias);
175			}
176
177			/*
178			* Selection
179			*/
180
181			/**
182			* @param mixed $field
183			*
184			* @return Select
185			*/
186			public static function select($field)
			0 ignored issues – show Unused Code introduced 2019-04-22 08:28 UTC by Report Bug Copy Issue Report The parameter `$field` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
187			{
188			return new Select(func_get_args());
189			}
190
191			/**
192			* @param mixed $field
193			*
194			* @return AddSelect
195			*/
196			public static function addSelect($field)
			0 ignored issues – show Unused Code introduced 2019-04-22 08:28 UTC by Report Bug Copy Issue Report The parameter `$field` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
197			{
198			return new AddSelect(func_get_args());
199			}
200
201			/**
202			* @param string $dqlAlias
203			*
204			* @return SelectEntity
205			*/
206			public static function selectEntity($dqlAlias)
207			{
208			return new SelectEntity($dqlAlias);
209			}
210
211			/**
212			* @param Filter\|Operand\|string $expression
213			* @param string $alias
214			*
215			* @return SelectAs
216			*/
217			public static function selectAs($expression, $alias)
218			{
219			return new SelectAs($expression, $alias);
220			}
221
222			/**
223			* @param Filter\|Operand\|string $expression
224			* @param string $alias
225			*
226			* @return SelectHiddenAs
227			*/
228			public static function selectHiddenAs($expression, $alias)
229			{
230			return new SelectHiddenAs($expression, $alias);
231			}
232
233			/*
234			* Result modifier
235			*/
236
237			/**
238			* @return AsArray
239			*/
240			public static function asArray()
241			{
242			return new AsArray();
243			}
244
245			/**
246			* @return AsSingleScalar
247			*/
248			public static function asSingleScalar()
249			{
250			return new AsSingleScalar();
251			}
252
253			/**
254			* @param int $cacheLifetime How many seconds the cached entry is valid
255			*
256			* @return Cache
257			*/
258			public static function cache($cacheLifetime)
259			{
260			return new Cache($cacheLifetime);
261			}
262
263			/**
264			* @param int $roundSeconds How may seconds to round time
265			*
266			* @return RoundDateTime
267			*/
268			public static function roundDateTimeParams($roundSeconds)
269			{
270			return new RoundDateTime($roundSeconds);
271			}
272
273			/*
274			* Filters
275			*/
276
277			/**
278			* @param Operand\|string $field
279			* @param string\|null $dqlAlias
280			*
281			* @return IsNull
282			*/
283			public static function isNull($field, $dqlAlias = null)
284			{
285			return new IsNull($field, $dqlAlias);
286			}
287
288			/**
289			* @param Operand\|string $field
290			* @param string\|null $dqlAlias
291			*
292			* @return IsNotNull
293			*/
294			public static function isNotNull($field, $dqlAlias = null)
295			{
296			return new IsNotNull($field, $dqlAlias);
297			}
298
299			/**
300			* Make sure the $field has a value equals to $value.
301			*
302			* @param string $field
303			* @param mixed $value
304			* @param string $dqlAlias
305			*
306			* @return In
307			*/
308			public static function in($field, $value, $dqlAlias = null)
309			{
310			return new In($field, $value, $dqlAlias);
311			}
312
313			/**
314			* @param string $field
315			* @param mixed $value
316			* @param string $dqlAlias
317			*
318			* @return Not
319			*/
320			public static function notIn($field, $value, $dqlAlias = null)
321			{
322			return new Not(new In($field, $value, $dqlAlias));
323			}
324
325			/**
326			* @param Operand\|string $field
327			* @param Operand\|mixed $value
328			* @param string\|null $dqlAlias
329			*
330			* @return Comparison
331			*/
332			public static function eq($field, $value, $dqlAlias = null)
333			{
334			return new Comparison(Comparison::EQ, $field, $value, $dqlAlias);
335			}
336
337			/**
338			* @param Operand\|string $field
339			* @param Operand\|mixed $value
340			* @param string\|null $dqlAlias
341			*
342			* @return Comparison
343			*/
344			public static function neq($field, $value, $dqlAlias = null)
345			{
346			return new Comparison(Comparison::NEQ, $field, $value, $dqlAlias);
347			}
348
349			/**
350			* @param Operand\|string $field
351			* @param Operand\|mixed $value
352			* @param string\|null $dqlAlias
353			*
354			* @return Comparison
355			*/
356			public static function lt($field, $value, $dqlAlias = null)
357			{
358			return new Comparison(Comparison::LT, $field, $value, $dqlAlias);
359			}
360
361			/**
362			* @param Operand\|string $field
363			* @param Operand\|mixed $value
364			* @param string\|null $dqlAlias
365			*
366			* @return Comparison
367			*/
368			public static function lte($field, $value, $dqlAlias = null)
369			{
370			return new Comparison(Comparison::LTE, $field, $value, $dqlAlias);
371			}
372
373			/**
374			* @param Operand\|string $field
375			* @param Operand\|mixed $value
376			* @param string\|null $dqlAlias
377			*
378			* @return Comparison
379			*/
380			public static function gt($field, $value, $dqlAlias = null)
381			{
382			return new Comparison(Comparison::GT, $field, $value, $dqlAlias);
383			}
384
385			/**
386			* @param Operand\|string $field
387			* @param Operand\|mixed $value
388			* @param string\|null $dqlAlias
389			*
390			* @return Comparison
391			*/
392			public static function gte($field, $value, $dqlAlias = null)
393			{
394			return new Comparison(Comparison::GTE, $field, $value, $dqlAlias);
395			}
396
397			/**
398			* @param Operand\|string $field
399			* @param string $value
400			* @param string $format
401			* @param string\|null $dqlAlias
402			*
403			* @return Like
404			*/
405			public static function like($field, $value, $format = Like::CONTAINS, $dqlAlias = null)
406			{
407			return new Like($field, $value, $format, $dqlAlias);
408			}
409
410			/**
411			* @param string $value
412			* @param string\|null $dqlAlias
413			*
414			* @return InstanceOfX
415			*/
416			public static function instanceOfX($value, $dqlAlias = null)
417			{
418			return new InstanceOfX($value, $dqlAlias);
419			}
420
421			/*
422			* Specifications
423			*/
424
425			/**
426			* @param Filter\|QueryModifier $spec
427			*
428			* @return CountOf
429			*/
430			public static function countOf($spec)
431			{
432			return new CountOf($spec);
433			}
434
435			/**
436			* @param Filter\|string $spec
437			*
438			* @return Having
439			*/
440			public static function having($spec)
441			{
442			return new Having($spec);
443			}
444
445			/*
446			* Operands
447			*/
448
449			/**
450			* @param string $fieldName
451			*
452			* @return Field
453			*/
454			public static function field($fieldName)
455			{
456			return new Field($fieldName);
457			}
458
459			/**
460			* @param mixed $value
461			* @param int\|string\|null $valueType
462			*
463			* @return Value
464			*/
465			public static function value($value, $valueType = null)
466			{
467			return new Value($value, $valueType);
468			}
469
470			/**
471			* @param array $values
472			* @param int\|string\|null $valueType
473			*
474			* @return Values
475			*/
476			public static function values($values, $valueType = null)
477			{
478			return new Values($values, $valueType);
479			}
480
481			/**
482			* @param string $value
483			* @param string $format
484			*
485			* @return LikePattern
486			*/
487			public static function likePattern($value, $format = LikePattern::CONTAINS)
488			{
489			return new LikePattern($value, $format);
490			}
491
492			/**
493			* @param string $alias
494			*
495			* @return Alias
496			*/
497			public static function alias($alias)
498			{
499			return new Alias($alias);
500			}
501			}
502

Happyr / Doctrine-Specification

Push — 1.0 ( 75b22b...f155d9 )

Spec::selectHiddenAs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like