jojo1981 / data-resolver / 170

pending completion

Build # 170

Build Type

cron

travis-ci-com

Committed by

jojo1981

Commit Message

Fix error: `Argument 1 passed to Jojo1981\DataResolver\Resolver\Context::pushPathPart() must be of the type string, int given, called in...`

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

454 of 868 relevant lines covered (52.3%)

5.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Factory/PredicateBuilderFactory.php

<?php declare(strict_types=1);
/*
 * This file is part of the jojo1981/data-resolver package
 *
 * Copyright (c) 2019 Joost Nijhuis <jnijhuis81@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed in the root of the source code
 */
namespace Jojo1981\DataResolver\Factory;

use Jojo1981\DataResolver\Builder\ExtractorBuilderInterface;
use Jojo1981\DataResolver\Builder\Predicate\AllPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\AndPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\BooleanPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\CallBackPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\ConditionalPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\CountPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\EqualsPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\ExtractorPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\GreaterThanPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\HasPropertyPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\InPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\IsEmptyPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\LessThanPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\NonePredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\NotPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\NullPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\OrPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\PredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\SomePredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\StringContainsPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\StringEndsWithPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\StringRegexPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\StringStartsWithPredicateBuilder;
use Jojo1981\DataResolver\Builder\PredicateBuilderInterface;
use Jojo1981\DataResolver\Comparator\ComparatorInterface;
use Jojo1981\DataResolver\Handler\SequenceHandlerInterface;

/**
 * @internal
 * @package Jojo1981\DataResolver\Factory
 */
final class PredicateBuilderFactory
{
    /** @var ExtractorBuilderFactory */
    private ExtractorBuilderFactory $extractorBuilderFactory;

    /** @var SequenceHandlerInterface */
    private SequenceHandlerInterface $sequenceHandler;

    /** @var ComparatorInterface */
    private ComparatorInterface $comparator;

    /**
     * @param ExtractorBuilderFactory $extractorBuilderFactory
     * @param SequenceHandlerInterface $sequenceHandler
     * @param ComparatorInterface $comparator
     */
    public function __construct(
        ExtractorBuilderFactory $extractorBuilderFactory,
        SequenceHandlerInterface $sequenceHandler,
        ComparatorInterface $comparator
    ) {
        $this->extractorBuilderFactory = $extractorBuilderFactory;
        $this->sequenceHandler = $sequenceHandler;
        $this->comparator = $comparator;
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return AllPredicateBuilder
     */
    public function getAllPredicateBuilder(PredicateBuilderInterface $predicateBuilder): AllPredicateBuilder
    {
        return new AllPredicateBuilder($this->sequenceHandler, $predicateBuilder->build());
    }

    /**
     * @param PredicateBuilderInterface $leftPredicateBuilder
     * @param PredicateBuilderInterface $rightPredicateBuilder
     * @return AndPredicateBuilder
     */
    public function getAndPredicateBuilder(
        PredicateBuilderInterface $leftPredicateBuilder,
        PredicateBuilderInterface $rightPredicateBuilder
    ): AndPredicateBuilder {
        return new AndPredicateBuilder($leftPredicateBuilder->build(), $rightPredicateBuilder->build());
    }

    /**
     * @param ExtractorBuilderInterface $extractorBuilder
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ConditionalPredicateBuilder
     */
    public function getConditionalPredicateBuilder(
        ExtractorBuilderInterface $extractorBuilder,
        PredicateBuilderInterface $predicateBuilder
    ): ConditionalPredicateBuilder {
        return new ConditionalPredicateBuilder($this, $extractorBuilder->build(), $predicateBuilder->build());
    }

    /**
     * @param mixed $referenceValue
     * @return EqualsPredicateBuilder
     */
    public function getEqualsPredicateBuilder($referenceValue): EqualsPredicateBuilder
    {
        return new EqualsPredicateBuilder($this->comparator, $referenceValue);
    }

    /**
     * @param mixed $referenceValue
     * @return GreaterThanPredicateBuilder
     */
    public function getGreaterThanPredicateBuilder($referenceValue): GreaterThanPredicateBuilder
    {
        return new GreaterThanPredicateBuilder($this->comparator, $referenceValue);
    }

    /**
     * @param mixed $referenceValue
     * @return LessThanPredicateBuilder
     */
    public function getLessThanPredicateBuilder($referenceValue): LessThanPredicateBuilder
    {
        return new LessThanPredicateBuilder($this->comparator, $referenceValue);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return NotPredicateBuilder
     */
    public function getNotPredicateBuilder(PredicateBuilderInterface $predicateBuilder): NotPredicateBuilder
    {
        return new NotPredicateBuilder($predicateBuilder->build());
    }

    /**
     * @param callable $callback
     * @return CallBackPredicateBuilder
     */
    public function getCallBackPredicateBuilder(callable $callback): CallBackPredicateBuilder
    {
        return new CallBackPredicateBuilder($callback);
    }

    /**
     * @param ExtractorBuilderInterface $extractorBuilder
     * @return ExtractorPredicateBuilder
     */
    public function getExtractorPredicateBuilder(ExtractorBuilderInterface $extractorBuilder): ExtractorPredicateBuilder
    {
        return new ExtractorPredicateBuilder($this, $this->extractorBuilderFactory, $extractorBuilder);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return NonePredicateBuilder
     */
    public function getNonePredicateBuilder(PredicateBuilderInterface $predicateBuilder): NonePredicateBuilder
    {
        return new NonePredicateBuilder($this->sequenceHandler, $predicateBuilder->build());
    }

    /**
     * @param PredicateBuilderInterface $leftPredicateBuilder
     * @param PredicateBuilderInterface $rightPredicateBuilder
     * @return OrPredicateBuilder
     */
    public function getOrPredicateBuilder(
        PredicateBuilderInterface $leftPredicateBuilder,
        PredicateBuilderInterface $rightPredicateBuilder
    ): OrPredicateBuilder {
        return new OrPredicateBuilder($leftPredicateBuilder->build(), $rightPredicateBuilder->build());
    }

    /**
     * @param array $expectedValues
     * @return InPredicateBuilder
     */
    public function getInPredicateBuilder(array $expectedValues): InPredicateBuilder
    {
        return new InPredicateBuilder($expectedValues, $this->comparator);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return PredicateBuilder
     */
    public function getPredicateBuilder(PredicateBuilderInterface $predicateBuilder): PredicateBuilder
    {
        return new PredicateBuilder($predicateBuilder->build());
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return SomePredicateBuilder
     */
    public function getSomePredicateBuilder(PredicateBuilderInterface $predicateBuilder): SomePredicateBuilder
    {
        return new SomePredicateBuilder($this->sequenceHandler, $predicateBuilder->build());
    }

    /**
     * @param string $prefix
     * @param bool $caseSensitive
     * @return StringStartsWithPredicateBuilder
     */
    public function getStringStartsWithPredicateBuilder(
        string $prefix,
        bool $caseSensitive
    ): StringStartsWithPredicateBuilder {
        return new StringStartsWithPredicateBuilder($prefix, $caseSensitive);
    }

    /**
     * @param string $suffix
     * @param bool $caseSensitive
     * @return StringEndsWithPredicateBuilder
     */
    public function getStringEndsWithPredicateBuilder(
        string $suffix,
        bool $caseSensitive
    ): StringEndsWithPredicateBuilder {
        return new StringEndsWithPredicateBuilder($suffix, $caseSensitive);
    }

    /**
     * @param string $subString
     * @param bool $caseSensitive
     * @return StringContainsPredicateBuilder
     */
    public function getStringContainsPredicateBuilder(
        string $subString,
        bool $caseSensitive
    ): StringContainsPredicateBuilder {
        return new StringContainsPredicateBuilder($subString, $caseSensitive);
    }

    /**
     * @param string $pattern
     * @return StringRegexPredicateBuilder
     */
    public function getStringRegexPredicateBuilder(string $pattern): StringRegexPredicateBuilder
    {
        return new StringRegexPredicateBuilder($pattern);
    }

    /**
     * @param string $propertyName
     * @return HasPropertyPredicateBuilder
     */
    public function getHasPropertyPredicateBuilder(string $propertyName): HasPropertyPredicateBuilder
    {
        return new HasPropertyPredicateBuilder(
            $this->extractorBuilderFactory->getHasPropertyExtractorBuilder($propertyName)->build()
        );
    }

    /**
     * @param bool $expected
     * @param bool $strict
     * @return BooleanPredicateBuilder
     */
    public function getBooleanPredicateBuilder(bool $expected, bool $strict): BooleanPredicateBuilder
    {
        return new BooleanPredicateBuilder($expected, $strict);
    }

    /**
     * @return NullPredicateBuilder
     */
    public function getNullPredicateBuilder(): NullPredicateBuilder
    {
        return new NullPredicateBuilder();
    }

    /**
     * @return IsEmptyPredicateBuilder
     */
    public function getIsEmptyPredicateBuilder(): IsEmptyPredicateBuilder
    {
        return new IsEmptyPredicateBuilder($this->sequenceHandler);
    }

    /**
     * @param int $expectedCount
     * @return CountPredicateBuilder
     */
    public function getCountPredicateBuilder(int $expectedCount): CountPredicateBuilder
    {
        return new CountPredicateBuilder($this->sequenceHandler, $expectedCount);
    }
}

1	<?php declare(strict_types=1);
2	/*
3	* This file is part of the jojo1981/data-resolver package
4	*
5	* Copyright (c) 2019 Joost Nijhuis <jnijhuis81@gmail.com>
6	*
7	* For the full copyright and license information, please view the LICENSE
8	* file that was distributed in the root of the source code
9	*/
10	namespace Jojo1981\DataResolver\Factory;
11
12	use Jojo1981\DataResolver\Builder\ExtractorBuilderInterface;
13	use Jojo1981\DataResolver\Builder\Predicate\AllPredicateBuilder;
14	use Jojo1981\DataResolver\Builder\Predicate\AndPredicateBuilder;
15	use Jojo1981\DataResolver\Builder\Predicate\BooleanPredicateBuilder;
16	use Jojo1981\DataResolver\Builder\Predicate\CallBackPredicateBuilder;
17	use Jojo1981\DataResolver\Builder\Predicate\ConditionalPredicateBuilder;
18	use Jojo1981\DataResolver\Builder\Predicate\CountPredicateBuilder;
19	use Jojo1981\DataResolver\Builder\Predicate\EqualsPredicateBuilder;
20	use Jojo1981\DataResolver\Builder\Predicate\ExtractorPredicateBuilder;
21	use Jojo1981\DataResolver\Builder\Predicate\GreaterThanPredicateBuilder;
22	use Jojo1981\DataResolver\Builder\Predicate\HasPropertyPredicateBuilder;
23	use Jojo1981\DataResolver\Builder\Predicate\InPredicateBuilder;
24	use Jojo1981\DataResolver\Builder\Predicate\IsEmptyPredicateBuilder;
25	use Jojo1981\DataResolver\Builder\Predicate\LessThanPredicateBuilder;
26	use Jojo1981\DataResolver\Builder\Predicate\NonePredicateBuilder;
27	use Jojo1981\DataResolver\Builder\Predicate\NotPredicateBuilder;
28	use Jojo1981\DataResolver\Builder\Predicate\NullPredicateBuilder;
29	use Jojo1981\DataResolver\Builder\Predicate\OrPredicateBuilder;
30	use Jojo1981\DataResolver\Builder\Predicate\PredicateBuilder;
31	use Jojo1981\DataResolver\Builder\Predicate\SomePredicateBuilder;
32	use Jojo1981\DataResolver\Builder\Predicate\StringContainsPredicateBuilder;
33	use Jojo1981\DataResolver\Builder\Predicate\StringEndsWithPredicateBuilder;
34	use Jojo1981\DataResolver\Builder\Predicate\StringRegexPredicateBuilder;
35	use Jojo1981\DataResolver\Builder\Predicate\StringStartsWithPredicateBuilder;
36	use Jojo1981\DataResolver\Builder\PredicateBuilderInterface;
37	use Jojo1981\DataResolver\Comparator\ComparatorInterface;
38	use Jojo1981\DataResolver\Handler\SequenceHandlerInterface;
39
40	/**
41	* @internal
42	* @package Jojo1981\DataResolver\Factory
43	*/
44	final class PredicateBuilderFactory
45	{
46	/** @var ExtractorBuilderFactory */
47	private ExtractorBuilderFactory $extractorBuilderFactory;
48
49	/** @var SequenceHandlerInterface */
50	private SequenceHandlerInterface $sequenceHandler;
51
52	/** @var ComparatorInterface */
53	private ComparatorInterface $comparator;
54
55	/**
56	* @param ExtractorBuilderFactory $extractorBuilderFactory
57	* @param SequenceHandlerInterface $sequenceHandler
58	* @param ComparatorInterface $comparator
59	*/
60	public function __construct(
61	ExtractorBuilderFactory $extractorBuilderFactory,
62	SequenceHandlerInterface $sequenceHandler,
63	ComparatorInterface $comparator
64	) {
65	$this->extractorBuilderFactory = $extractorBuilderFactory;	×
66	$this->sequenceHandler = $sequenceHandler;	×
67	$this->comparator = $comparator;	×
68	}
69
70	/**
71	* @param PredicateBuilderInterface $predicateBuilder
72	* @return AllPredicateBuilder
73	*/
74	public function getAllPredicateBuilder(PredicateBuilderInterface $predicateBuilder): AllPredicateBuilder
75	{
76	return new AllPredicateBuilder($this->sequenceHandler, $predicateBuilder->build());	×
77	}
78
79	/**
80	* @param PredicateBuilderInterface $leftPredicateBuilder
81	* @param PredicateBuilderInterface $rightPredicateBuilder
82	* @return AndPredicateBuilder
83	*/
84	public function getAndPredicateBuilder(
85	PredicateBuilderInterface $leftPredicateBuilder,
86	PredicateBuilderInterface $rightPredicateBuilder
87	): AndPredicateBuilder {
88	return new AndPredicateBuilder($leftPredicateBuilder->build(), $rightPredicateBuilder->build());	×
89	}
90
91	/**
92	* @param ExtractorBuilderInterface $extractorBuilder
93	* @param PredicateBuilderInterface $predicateBuilder
94	* @return ConditionalPredicateBuilder
95	*/
96	public function getConditionalPredicateBuilder(
97	ExtractorBuilderInterface $extractorBuilder,
98	PredicateBuilderInterface $predicateBuilder
99	): ConditionalPredicateBuilder {
100	return new ConditionalPredicateBuilder($this, $extractorBuilder->build(), $predicateBuilder->build());	×
101	}
102
103	/**
104	* @param mixed $referenceValue
105	* @return EqualsPredicateBuilder
106	*/
107	public function getEqualsPredicateBuilder($referenceValue): EqualsPredicateBuilder
108	{
109	return new EqualsPredicateBuilder($this->comparator, $referenceValue);	×
110	}
111
112	/**
113	* @param mixed $referenceValue
114	* @return GreaterThanPredicateBuilder
115	*/
116	public function getGreaterThanPredicateBuilder($referenceValue): GreaterThanPredicateBuilder
117	{
118	return new GreaterThanPredicateBuilder($this->comparator, $referenceValue);	×
119	}
120
121	/**
122	* @param mixed $referenceValue
123	* @return LessThanPredicateBuilder
124	*/
125	public function getLessThanPredicateBuilder($referenceValue): LessThanPredicateBuilder
126	{
127	return new LessThanPredicateBuilder($this->comparator, $referenceValue);	×
128	}
129
130	/**
131	* @param PredicateBuilderInterface $predicateBuilder
132	* @return NotPredicateBuilder
133	*/
134	public function getNotPredicateBuilder(PredicateBuilderInterface $predicateBuilder): NotPredicateBuilder
135	{
136	return new NotPredicateBuilder($predicateBuilder->build());	×
137	}
138
139	/**
140	* @param callable $callback
141	* @return CallBackPredicateBuilder
142	*/
143	public function getCallBackPredicateBuilder(callable $callback): CallBackPredicateBuilder
144	{
145	return new CallBackPredicateBuilder($callback);	×
146	}
147
148	/**
149	* @param ExtractorBuilderInterface $extractorBuilder
150	* @return ExtractorPredicateBuilder
151	*/
152	public function getExtractorPredicateBuilder(ExtractorBuilderInterface $extractorBuilder): ExtractorPredicateBuilder
153	{
154	return new ExtractorPredicateBuilder($this, $this->extractorBuilderFactory, $extractorBuilder);	×
155	}
156
157	/**
158	* @param PredicateBuilderInterface $predicateBuilder
159	* @return NonePredicateBuilder
160	*/
161	public function getNonePredicateBuilder(PredicateBuilderInterface $predicateBuilder): NonePredicateBuilder
162	{
163	return new NonePredicateBuilder($this->sequenceHandler, $predicateBuilder->build());	×
164	}
165
166	/**
167	* @param PredicateBuilderInterface $leftPredicateBuilder
168	* @param PredicateBuilderInterface $rightPredicateBuilder
169	* @return OrPredicateBuilder
170	*/
171	public function getOrPredicateBuilder(
172	PredicateBuilderInterface $leftPredicateBuilder,
173	PredicateBuilderInterface $rightPredicateBuilder
174	): OrPredicateBuilder {
175	return new OrPredicateBuilder($leftPredicateBuilder->build(), $rightPredicateBuilder->build());	×
176	}
177
178	/**
179	* @param array $expectedValues
180	* @return InPredicateBuilder
181	*/
182	public function getInPredicateBuilder(array $expectedValues): InPredicateBuilder
183	{
184	return new InPredicateBuilder($expectedValues, $this->comparator);	×
185	}
186
187	/**
188	* @param PredicateBuilderInterface $predicateBuilder
189	* @return PredicateBuilder
190	*/
191	public function getPredicateBuilder(PredicateBuilderInterface $predicateBuilder): PredicateBuilder
192	{
193	return new PredicateBuilder($predicateBuilder->build());	×
194	}
195
196	/**
197	* @param PredicateBuilderInterface $predicateBuilder
198	* @return SomePredicateBuilder
199	*/
200	public function getSomePredicateBuilder(PredicateBuilderInterface $predicateBuilder): SomePredicateBuilder
201	{
202	return new SomePredicateBuilder($this->sequenceHandler, $predicateBuilder->build());	×
203	}
204
205	/**
206	* @param string $prefix
207	* @param bool $caseSensitive
208	* @return StringStartsWithPredicateBuilder
209	*/
210	public function getStringStartsWithPredicateBuilder(
211	string $prefix,
212	bool $caseSensitive
213	): StringStartsWithPredicateBuilder {
214	return new StringStartsWithPredicateBuilder($prefix, $caseSensitive);	×
215	}
216
217	/**
218	* @param string $suffix
219	* @param bool $caseSensitive
220	* @return StringEndsWithPredicateBuilder
221	*/
222	public function getStringEndsWithPredicateBuilder(
223	string $suffix,
224	bool $caseSensitive
225	): StringEndsWithPredicateBuilder {
226	return new StringEndsWithPredicateBuilder($suffix, $caseSensitive);	×
227	}
228
229	/**
230	* @param string $subString
231	* @param bool $caseSensitive
232	* @return StringContainsPredicateBuilder
233	*/
234	public function getStringContainsPredicateBuilder(
235	string $subString,
236	bool $caseSensitive
237	): StringContainsPredicateBuilder {
238	return new StringContainsPredicateBuilder($subString, $caseSensitive);	×
239	}
240
241	/**
242	* @param string $pattern
243	* @return StringRegexPredicateBuilder
244	*/
245	public function getStringRegexPredicateBuilder(string $pattern): StringRegexPredicateBuilder
246	{
247	return new StringRegexPredicateBuilder($pattern);	×
248	}
249
250	/**
251	* @param string $propertyName
252	* @return HasPropertyPredicateBuilder
253	*/
254	public function getHasPropertyPredicateBuilder(string $propertyName): HasPropertyPredicateBuilder
255	{
256	return new HasPropertyPredicateBuilder(	×
257	$this->extractorBuilderFactory->getHasPropertyExtractorBuilder($propertyName)->build()	×
258	);	×
259	}
260
261	/**
262	* @param bool $expected
263	* @param bool $strict
264	* @return BooleanPredicateBuilder
265	*/
266	public function getBooleanPredicateBuilder(bool $expected, bool $strict): BooleanPredicateBuilder
267	{
268	return new BooleanPredicateBuilder($expected, $strict);	×
269	}
270
271	/**
272	* @return NullPredicateBuilder
273	*/
274	public function getNullPredicateBuilder(): NullPredicateBuilder
275	{
276	return new NullPredicateBuilder();	×
277	}
278
279	/**
280	* @return IsEmptyPredicateBuilder
281	*/
282	public function getIsEmptyPredicateBuilder(): IsEmptyPredicateBuilder
283	{
284	return new IsEmptyPredicateBuilder($this->sequenceHandler);	×
285	}
286
287	/**
288	* @param int $expectedCount
289	* @return CountPredicateBuilder
290	*/
291	public function getCountPredicateBuilder(int $expectedCount): CountPredicateBuilder
292	{
293	return new CountPredicateBuilder($this->sequenceHandler, $expectedCount);	×
294	}
295	}

jojo1981 / data-resolver / 170

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous