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/Builder/Predicate/ExtractorPredicateBuilder.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\Builder\Predicate;

use Jojo1981\DataResolver\Builder\ExtractorBuilderInterface;
use Jojo1981\DataResolver\Builder\PredicateBuilderInterface;
use Jojo1981\DataResolver\Factory\ExtractorBuilderFactory;
use Jojo1981\DataResolver\Factory\PredicateBuilderFactory;

/**
 * Not a predicate builder but a man in the middle to force correctly building the predicate
 *
 * @api
 * @package Jojo1981\DataResolver\Builder\Predicate
 */
final class ExtractorPredicateBuilder
{
    /** @var PredicateBuilderFactory */
    private PredicateBuilderFactory $predicateBuilderFactory;

    /** @var ExtractorBuilderFactory */
    private ExtractorBuilderFactory $extractorBuilderFactory;

    /** @var ExtractorBuilderInterface */
    private ExtractorBuilderInterface $extractorBuilder;

    /**
     * @param PredicateBuilderFactory $predicateBuilderFactory
     * @param ExtractorBuilderFactory $extractorBuilderFactory
     * @param ExtractorBuilderInterface $extractorBuilder
     */
    public function __construct(
        PredicateBuilderFactory $predicateBuilderFactory,
        ExtractorBuilderFactory $extractorBuilderFactory,
        ExtractorBuilderInterface $extractorBuilder
    ) {
        $this->predicateBuilderFactory = $predicateBuilderFactory;
        $this->extractorBuilderFactory = $extractorBuilderFactory;
        $this->extractorBuilder = $extractorBuilder;
    }

    /**
     * @param string $propertyName
     * @return ExtractorPredicateBuilder
     */
    public function get(string $propertyName): ExtractorPredicateBuilder
    {
        return $this->predicateBuilderFactory->getExtractorPredicateBuilder(
            $this->extractorBuilderFactory->getCompositeExtractorBuilder(
                $this->extractorBuilder,
                $this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)
            )
        );
    }

    /**
     * @param mixed $referenceValue
     * @return ConditionalPredicateBuilder
     */
    public function equals($referenceValue): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue)
        );
    }

    /**
     * @param mixed $referenceValue
     * @return ConditionalPredicateBuilder
     */
    public function greaterThan($referenceValue): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getGreaterThanPredicateBuilder($referenceValue)
        );
    }

    /**
     * @param mixed $referenceValue
     * @return ConditionalPredicateBuilder
     */
    public function lessThan($referenceValue): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getLessThanPredicateBuilder($referenceValue)
        );
    }

    /**
     * @param mixed $referenceValue
     * @return ConditionalPredicateBuilder
     */
    public function greaterThanOrEquals($referenceValue): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getOrPredicateBuilder(
                $this->predicateBuilderFactory->getGreaterThanPredicateBuilder($referenceValue),
                $this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue)
            )
        );
    }

    /**
     * @param mixed $referenceValue
     * @return ConditionalPredicateBuilder
     */
    public function lessThanOrEquals($referenceValue): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getOrPredicateBuilder(
                $this->predicateBuilderFactory->getLessThanPredicateBuilder($referenceValue),
                $this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue)
            )
        );
    }

    /**
     * @param mixed $referenceValue
     * @return ConditionalPredicateBuilder
     */
    public function notEquals($referenceValue): ConditionalPredicateBuilder
    {
        return $this->not($this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue));
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isTrue(): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getBooleanPredicateBuilder(true, true)
        );
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isTruly(): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getBooleanPredicateBuilder(true, false)
        );
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isFalse(): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getBooleanPredicateBuilder(false, true)
        );
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isFalsely(): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getBooleanPredicateBuilder(false, false)
        );
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isNull(): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder($this->predicateBuilderFactory->getNullPredicateBuilder());
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isNotNull(): ConditionalPredicateBuilder
    {
        return $this->not($this->predicateBuilderFactory->getNullPredicateBuilder());
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isEmpty(): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder($this->predicateBuilderFactory->getIsEmptyPredicateBuilder());
    }

    /**
     * @return ConditionalPredicateBuilder
     */
    public function isNotEmpty(): ConditionalPredicateBuilder
    {
        return $this->not($this->predicateBuilderFactory->getIsEmptyPredicateBuilder());
    }

    /**
     * @param callable $callback
     * @return ConditionalPredicateBuilder
     */
    public function callback(callable $callback): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getCallBackPredicateBuilder($callback)
        );
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ConditionalPredicateBuilder
     */
    public function not(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getNotPredicateBuilder($predicateBuilder)
        );
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ConditionalPredicateBuilder
     */
    public function some(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getSomePredicateBuilder($predicateBuilder)
        );
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ConditionalPredicateBuilder
     */
    public function all(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getAllPredicateBuilder($predicateBuilder)
        );
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ConditionalPredicateBuilder
     */
    public function none(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getNonePredicateBuilder($predicateBuilder)
        );
    }

    /**
     * @param array $expectedValues
     * @return ConditionalPredicateBuilder
     */
    public function in(array $expectedValues): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getInPredicateBuilder($expectedValues)
        );
    }

    /**
     * @param array $expectedValues
     * @return ConditionalPredicateBuilder
     */
    public function notIn(array $expectedValues): ConditionalPredicateBuilder
    {
        return $this->not($this->predicateBuilderFactory->getInPredicateBuilder($expectedValues));
    }

    /**
     * @param int $expectedCount
     * @return ConditionalPredicateBuilder
     */
    public function hasCount(int $expectedCount): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getCountPredicateBuilder($expectedCount)
        );
    }

    /**
     * @param int $expectedCount
     * @return ConditionalPredicateBuilder
     */
    public function hasNotCount(int $expectedCount): ConditionalPredicateBuilder
    {
        return $this->not($this->predicateBuilderFactory->getCountPredicateBuilder($expectedCount));
    }

    /**
     * @param string $prefix
     * @param bool $caseSensitive
     * @return ConditionalPredicateBuilder
     */
    public function stringStartsWith(string $prefix, bool $caseSensitive = true): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getStringStartsWithPredicateBuilder($prefix, $caseSensitive)
        );
    }

    /**
     * @param string $suffix
     * @param bool $caseSensitive
     * @return ConditionalPredicateBuilder
     */
    public function stringEndsWith(string $suffix, bool $caseSensitive = true): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getStringEndsWithPredicateBuilder($suffix, $caseSensitive)
        );
    }

    /**
     * @param string $subString
     * @param bool $caseSensitive
     * @return ConditionalPredicateBuilder
     */
    public function stringContains(string $subString, bool $caseSensitive = true): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getStringContainsPredicateBuilder($subString, $caseSensitive)
        );
    }

    /**
     * @param string $pattern
     * @return ConditionalPredicateBuilder
     */
    public function stringMatchesRegex(string $pattern): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getStringRegexPredicateBuilder($pattern)
        );
    }

    /**
     * @param string $propertyName
     * @return ConditionalPredicateBuilder
     */
    public function hasProperty(string $propertyName): ConditionalPredicateBuilder
    {
        return $this->getConditionalPredicateBuilder(
            $this->predicateBuilderFactory->getHasPropertyPredicateBuilder($propertyName)
        );
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ConditionalPredicateBuilder
     */
    private function getConditionalPredicateBuilder(
        PredicateBuilderInterface $predicateBuilder
    ): ConditionalPredicateBuilder {
        return $this->predicateBuilderFactory->getConditionalPredicateBuilder(
            $this->extractorBuilder,
            $predicateBuilder
        );
    }
}

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\Builder\Predicate;
11
12	use Jojo1981\DataResolver\Builder\ExtractorBuilderInterface;
13	use Jojo1981\DataResolver\Builder\PredicateBuilderInterface;
14	use Jojo1981\DataResolver\Factory\ExtractorBuilderFactory;
15	use Jojo1981\DataResolver\Factory\PredicateBuilderFactory;
16
17	/**
18	* Not a predicate builder but a man in the middle to force correctly building the predicate
19	*
20	* @api
21	* @package Jojo1981\DataResolver\Builder\Predicate
22	*/
23	final class ExtractorPredicateBuilder
24	{
25	/** @var PredicateBuilderFactory */
26	private PredicateBuilderFactory $predicateBuilderFactory;
27
28	/** @var ExtractorBuilderFactory */
29	private ExtractorBuilderFactory $extractorBuilderFactory;
30
31	/** @var ExtractorBuilderInterface */
32	private ExtractorBuilderInterface $extractorBuilder;
33
34	/**
35	* @param PredicateBuilderFactory $predicateBuilderFactory
36	* @param ExtractorBuilderFactory $extractorBuilderFactory
37	* @param ExtractorBuilderInterface $extractorBuilder
38	*/
39	public function __construct(
40	PredicateBuilderFactory $predicateBuilderFactory,
41	ExtractorBuilderFactory $extractorBuilderFactory,
42	ExtractorBuilderInterface $extractorBuilder
43	) {
44	$this->predicateBuilderFactory = $predicateBuilderFactory;	×
45	$this->extractorBuilderFactory = $extractorBuilderFactory;	×
46	$this->extractorBuilder = $extractorBuilder;	×
47	}
48
49	/**
50	* @param string $propertyName
51	* @return ExtractorPredicateBuilder
52	*/
53	public function get(string $propertyName): ExtractorPredicateBuilder
54	{
55	return $this->predicateBuilderFactory->getExtractorPredicateBuilder(	×
56	$this->extractorBuilderFactory->getCompositeExtractorBuilder(	×
57	$this->extractorBuilder,	×
58	$this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)	×
59	)	×
60	);	×
61	}
62
63	/**
64	* @param mixed $referenceValue
65	* @return ConditionalPredicateBuilder
66	*/
67	public function equals($referenceValue): ConditionalPredicateBuilder
68	{
69	return $this->getConditionalPredicateBuilder(	×
70	$this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue)	×
71	);	×
72	}
73
74	/**
75	* @param mixed $referenceValue
76	* @return ConditionalPredicateBuilder
77	*/
78	public function greaterThan($referenceValue): ConditionalPredicateBuilder
79	{
80	return $this->getConditionalPredicateBuilder(	×
81	$this->predicateBuilderFactory->getGreaterThanPredicateBuilder($referenceValue)	×
82	);	×
83	}
84
85	/**
86	* @param mixed $referenceValue
87	* @return ConditionalPredicateBuilder
88	*/
89	public function lessThan($referenceValue): ConditionalPredicateBuilder
90	{
91	return $this->getConditionalPredicateBuilder(	×
92	$this->predicateBuilderFactory->getLessThanPredicateBuilder($referenceValue)	×
93	);	×
94	}
95
96	/**
97	* @param mixed $referenceValue
98	* @return ConditionalPredicateBuilder
99	*/
100	public function greaterThanOrEquals($referenceValue): ConditionalPredicateBuilder
101	{
102	return $this->getConditionalPredicateBuilder(	×
103	$this->predicateBuilderFactory->getOrPredicateBuilder(	×
104	$this->predicateBuilderFactory->getGreaterThanPredicateBuilder($referenceValue),	×
105	$this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue)	×
106	)	×
107	);	×
108	}
109
110	/**
111	* @param mixed $referenceValue
112	* @return ConditionalPredicateBuilder
113	*/
114	public function lessThanOrEquals($referenceValue): ConditionalPredicateBuilder
115	{
116	return $this->getConditionalPredicateBuilder(	×
117	$this->predicateBuilderFactory->getOrPredicateBuilder(	×
118	$this->predicateBuilderFactory->getLessThanPredicateBuilder($referenceValue),	×
119	$this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue)	×
120	)	×
121	);	×
122	}
123
124	/**
125	* @param mixed $referenceValue
126	* @return ConditionalPredicateBuilder
127	*/
128	public function notEquals($referenceValue): ConditionalPredicateBuilder
129	{
130	return $this->not($this->predicateBuilderFactory->getEqualsPredicateBuilder($referenceValue));	×
131	}
132
133	/**
134	* @return ConditionalPredicateBuilder
135	*/
136	public function isTrue(): ConditionalPredicateBuilder
137	{
138	return $this->getConditionalPredicateBuilder(	×
139	$this->predicateBuilderFactory->getBooleanPredicateBuilder(true, true)	×
140	);	×
141	}
142
143	/**
144	* @return ConditionalPredicateBuilder
145	*/
146	public function isTruly(): ConditionalPredicateBuilder
147	{
148	return $this->getConditionalPredicateBuilder(	×
149	$this->predicateBuilderFactory->getBooleanPredicateBuilder(true, false)	×
150	);	×
151	}
152
153	/**
154	* @return ConditionalPredicateBuilder
155	*/
156	public function isFalse(): ConditionalPredicateBuilder
157	{
158	return $this->getConditionalPredicateBuilder(	×
159	$this->predicateBuilderFactory->getBooleanPredicateBuilder(false, true)	×
160	);	×
161	}
162
163	/**
164	* @return ConditionalPredicateBuilder
165	*/
166	public function isFalsely(): ConditionalPredicateBuilder
167	{
168	return $this->getConditionalPredicateBuilder(	×
169	$this->predicateBuilderFactory->getBooleanPredicateBuilder(false, false)	×
170	);	×
171	}
172
173	/**
174	* @return ConditionalPredicateBuilder
175	*/
176	public function isNull(): ConditionalPredicateBuilder
177	{
178	return $this->getConditionalPredicateBuilder($this->predicateBuilderFactory->getNullPredicateBuilder());	×
179	}
180
181	/**
182	* @return ConditionalPredicateBuilder
183	*/
184	public function isNotNull(): ConditionalPredicateBuilder
185	{
186	return $this->not($this->predicateBuilderFactory->getNullPredicateBuilder());	×
187	}
188
189	/**
190	* @return ConditionalPredicateBuilder
191	*/
192	public function isEmpty(): ConditionalPredicateBuilder
193	{
194	return $this->getConditionalPredicateBuilder($this->predicateBuilderFactory->getIsEmptyPredicateBuilder());	×
195	}
196
197	/**
198	* @return ConditionalPredicateBuilder
199	*/
200	public function isNotEmpty(): ConditionalPredicateBuilder
201	{
202	return $this->not($this->predicateBuilderFactory->getIsEmptyPredicateBuilder());	×
203	}
204
205	/**
206	* @param callable $callback
207	* @return ConditionalPredicateBuilder
208	*/
209	public function callback(callable $callback): ConditionalPredicateBuilder
210	{
211	return $this->getConditionalPredicateBuilder(	×
212	$this->predicateBuilderFactory->getCallBackPredicateBuilder($callback)	×
213	);	×
214	}
215
216	/**
217	* @param PredicateBuilderInterface $predicateBuilder
218	* @return ConditionalPredicateBuilder
219	*/
220	public function not(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
221	{
222	return $this->getConditionalPredicateBuilder(	×
223	$this->predicateBuilderFactory->getNotPredicateBuilder($predicateBuilder)	×
224	);	×
225	}
226
227	/**
228	* @param PredicateBuilderInterface $predicateBuilder
229	* @return ConditionalPredicateBuilder
230	*/
231	public function some(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
232	{
233	return $this->getConditionalPredicateBuilder(	×
234	$this->predicateBuilderFactory->getSomePredicateBuilder($predicateBuilder)	×
235	);	×
236	}
237
238	/**
239	* @param PredicateBuilderInterface $predicateBuilder
240	* @return ConditionalPredicateBuilder
241	*/
242	public function all(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
243	{
244	return $this->getConditionalPredicateBuilder(	×
245	$this->predicateBuilderFactory->getAllPredicateBuilder($predicateBuilder)	×
246	);	×
247	}
248
249	/**
250	* @param PredicateBuilderInterface $predicateBuilder
251	* @return ConditionalPredicateBuilder
252	*/
253	public function none(PredicateBuilderInterface $predicateBuilder): ConditionalPredicateBuilder
254	{
255	return $this->getConditionalPredicateBuilder(	×
256	$this->predicateBuilderFactory->getNonePredicateBuilder($predicateBuilder)	×
257	);	×
258	}
259
260	/**
261	* @param array $expectedValues
262	* @return ConditionalPredicateBuilder
263	*/
264	public function in(array $expectedValues): ConditionalPredicateBuilder
265	{
266	return $this->getConditionalPredicateBuilder(	×
267	$this->predicateBuilderFactory->getInPredicateBuilder($expectedValues)	×
268	);	×
269	}
270
271	/**
272	* @param array $expectedValues
273	* @return ConditionalPredicateBuilder
274	*/
275	public function notIn(array $expectedValues): ConditionalPredicateBuilder
276	{
277	return $this->not($this->predicateBuilderFactory->getInPredicateBuilder($expectedValues));	×
278	}
279
280	/**
281	* @param int $expectedCount
282	* @return ConditionalPredicateBuilder
283	*/
284	public function hasCount(int $expectedCount): ConditionalPredicateBuilder
285	{
286	return $this->getConditionalPredicateBuilder(	×
287	$this->predicateBuilderFactory->getCountPredicateBuilder($expectedCount)	×
288	);	×
289	}
290
291	/**
292	* @param int $expectedCount
293	* @return ConditionalPredicateBuilder
294	*/
295	public function hasNotCount(int $expectedCount): ConditionalPredicateBuilder
296	{
297	return $this->not($this->predicateBuilderFactory->getCountPredicateBuilder($expectedCount));	×
298	}
299
300	/**
301	* @param string $prefix
302	* @param bool $caseSensitive
303	* @return ConditionalPredicateBuilder
304	*/
305	public function stringStartsWith(string $prefix, bool $caseSensitive = true): ConditionalPredicateBuilder
306	{
307	return $this->getConditionalPredicateBuilder(	×
308	$this->predicateBuilderFactory->getStringStartsWithPredicateBuilder($prefix, $caseSensitive)	×
309	);	×
310	}
311
312	/**
313	* @param string $suffix
314	* @param bool $caseSensitive
315	* @return ConditionalPredicateBuilder
316	*/
317	public function stringEndsWith(string $suffix, bool $caseSensitive = true): ConditionalPredicateBuilder
318	{
319	return $this->getConditionalPredicateBuilder(	×
320	$this->predicateBuilderFactory->getStringEndsWithPredicateBuilder($suffix, $caseSensitive)	×
321	);	×
322	}
323
324	/**
325	* @param string $subString
326	* @param bool $caseSensitive
327	* @return ConditionalPredicateBuilder
328	*/
329	public function stringContains(string $subString, bool $caseSensitive = true): ConditionalPredicateBuilder
330	{
331	return $this->getConditionalPredicateBuilder(	×
332	$this->predicateBuilderFactory->getStringContainsPredicateBuilder($subString, $caseSensitive)	×
333	);	×
334	}
335
336	/**
337	* @param string $pattern
338	* @return ConditionalPredicateBuilder
339	*/
340	public function stringMatchesRegex(string $pattern): ConditionalPredicateBuilder
341	{
342	return $this->getConditionalPredicateBuilder(	×
343	$this->predicateBuilderFactory->getStringRegexPredicateBuilder($pattern)	×
344	);	×
345	}
346
347	/**
348	* @param string $propertyName
349	* @return ConditionalPredicateBuilder
350	*/
351	public function hasProperty(string $propertyName): ConditionalPredicateBuilder
352	{
353	return $this->getConditionalPredicateBuilder(	×
354	$this->predicateBuilderFactory->getHasPropertyPredicateBuilder($propertyName)	×
355	);	×
356	}
357
358	/**
359	* @param PredicateBuilderInterface $predicateBuilder
360	* @return ConditionalPredicateBuilder
361	*/
362	private function getConditionalPredicateBuilder(
363	PredicateBuilderInterface $predicateBuilder
364	): ConditionalPredicateBuilder {
365	return $this->predicateBuilderFactory->getConditionalPredicateBuilder(	×
366	$this->extractorBuilder,	×
367	$predicateBuilder	×
368	);	×
369	}
370	}

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