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/ResolverBuilderFactory.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\Predicate\AndPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\ExtractorPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\NotPredicateBuilder;
use Jojo1981\DataResolver\Builder\Predicate\OrPredicateBuilder;
use Jojo1981\DataResolver\Builder\PredicateBuilderInterface;
use Jojo1981\DataResolver\Builder\ResolverBuilder;
use Jojo1981\DataResolver\Factory\Exception\FactoryException;
use Jojo1981\DataResolver\Resolver;
use function array_shift;
use function explode;
use function is_string;
use function sprintf;
use function strpos;
use function trim;

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

    /** @var PredicateBuilderFactory */
    private PredicateBuilderFactory $predicateBuilderFactory;

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

    /**
     * @return ResolverBuilder
     */
    public function create(): ResolverBuilder
    {
        return new ResolverBuilder($this->extractorBuilderFactory);
    }

    /**
     * @param ResolverBuilder $resolverBuilder
     * @return ResolverBuilder
     */
    public function compose(ResolverBuilder $resolverBuilder): ResolverBuilder
    {
        return new ResolverBuilder($this->extractorBuilderFactory, $resolverBuilder);
    }

    /**
     * @param string $propertyName
     * @param string ...$propertyNames
     * @return ResolverBuilder
     */
    public function get(string $propertyName, ...$propertyNames): ResolverBuilder
    {
        return $this->create()->get($propertyName, ...$propertyNames);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ResolverBuilder
     */
    public function filter(PredicateBuilderInterface $predicateBuilder): ResolverBuilder
    {
        return $this->create()->filter($predicateBuilder);
    }

    /**
     * @param ResolverBuilder $resolverBuilder
     * @return ResolverBuilder
     */
    public function flatten(ResolverBuilder $resolverBuilder): ResolverBuilder
    {
        return $this->create()->flatten($resolverBuilder);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return ResolverBuilder
     */
    public function find(PredicateBuilderInterface $predicateBuilder): ResolverBuilder
    {
        return $this->create()->find($predicateBuilder);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return Resolver
     */
    public function all(PredicateBuilderInterface $predicateBuilder): Resolver
    {
        return $this->create()->all($predicateBuilder);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return Resolver
     */
    public function none(PredicateBuilderInterface $predicateBuilder): Resolver
    {
        return $this->create()->none($predicateBuilder);
    }

    /**
     * @param PredicateBuilderInterface $predicateBuilder
     * @return Resolver
     */
    public function some(PredicateBuilderInterface $predicateBuilder): Resolver
    {
        return $this->create()->some($predicateBuilder);
    }

    /**
     * @return Resolver
     */
    public function count(): Resolver
    {
        return $this->create()->count();
    }

    /**
     * @return Resolver
     */
    public function strlen(): Resolver
    {
        return $this->create()->strlen();
    }

    /**
     * @param string $propertyName
     * @return Resolver
     */
    public function hasProperty(string $propertyName): Resolver
    {
        return $this->create()->hasProperty($propertyName);
    }

    /**
     * @param string|ResolverBuilder|null $arg
     * @return ExtractorPredicateBuilder
     * @throws FactoryException
     */
    public function where($arg = null): ExtractorPredicateBuilder
    {
        if (null === $arg) {
            return $this->predicateBuilderFactory->getExtractorPredicateBuilder(
                $this->extractorBuilderFactory->getResolverExtractorBuilder($this->create())
            );
        }

        if (is_string($arg)) {
            return $this->getExtractorPredicateBuilderForPropertyName($arg);
        }

        if ($arg instanceof ResolverBuilder) {
            return $this->predicateBuilderFactory->getExtractorPredicateBuilder(
                $this->extractorBuilderFactory->getResolverExtractorBuilder($arg)
            );
        }

        throw new FactoryException(sprintf(
            'Invalid argument given for method `where`, should be of type string or an instance of %s',
            ResolverBuilder::class
        ));
    }

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

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

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

    /**
     * @param string $propertyName
     * @return ExtractorPredicateBuilder
     */
    private function getExtractorPredicateBuilderForPropertyName(string $propertyName): ExtractorPredicateBuilder
    {
        $propertyName = trim($propertyName, '.');
        if (false === strpos($propertyName, '.')) {
            return $this->predicateBuilderFactory->getExtractorPredicateBuilder(
                $this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)
            );
        }

        return $this->getExtractorPredicateBuilderForPropertyNames(explode('.', $propertyName));
    }

    /**
     * @param string[] $propertyNames
     * @return ExtractorPredicateBuilder
     */
    private function getExtractorPredicateBuilderForPropertyNames(array $propertyNames): ExtractorPredicateBuilder
    {
        $extractorBuilder = $this->extractorBuilderFactory->getCompositeExtractorBuilder(
            $this->extractorBuilderFactory->getPropertyExtractorBuilder(array_shift($propertyNames)),
            $this->extractorBuilderFactory->getPropertyExtractorBuilder(array_shift($propertyNames))
        );

        foreach ($propertyNames as $propertyName) {
            $extractorBuilder = $this->extractorBuilderFactory->getCompositeExtractorBuilder(
                $extractorBuilder,
                $this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)
            );
        }

        return $this->predicateBuilderFactory->getExtractorPredicateBuilder($extractorBuilder);
    }
}

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\Predicate\AndPredicateBuilder;
13	use Jojo1981\DataResolver\Builder\Predicate\ExtractorPredicateBuilder;
14	use Jojo1981\DataResolver\Builder\Predicate\NotPredicateBuilder;
15	use Jojo1981\DataResolver\Builder\Predicate\OrPredicateBuilder;
16	use Jojo1981\DataResolver\Builder\PredicateBuilderInterface;
17	use Jojo1981\DataResolver\Builder\ResolverBuilder;
18	use Jojo1981\DataResolver\Factory\Exception\FactoryException;
19	use Jojo1981\DataResolver\Resolver;
20	use function array_shift;
21	use function explode;
22	use function is_string;
23	use function sprintf;
24	use function strpos;
25	use function trim;
26
27	/**
28	* @api
29	* @package Jojo1981\DataResolver\Factory
30	*/
31	final class ResolverBuilderFactory
32	{
33	/** @var ExtractorBuilderFactory */
34	private ExtractorBuilderFactory $extractorBuilderFactory;
35
36	/** @var PredicateBuilderFactory */
37	private PredicateBuilderFactory $predicateBuilderFactory;
38
39	/**
40	* @param ExtractorBuilderFactory $extractorBuilderFactory
41	* @param PredicateBuilderFactory $predicateBuilderFactory
42	*/
43	public function __construct(
44	ExtractorBuilderFactory $extractorBuilderFactory,
45	PredicateBuilderFactory $predicateBuilderFactory
46	) {
47	$this->extractorBuilderFactory = $extractorBuilderFactory;	×
48	$this->predicateBuilderFactory = $predicateBuilderFactory;	×
49	}
50
51	/**
52	* @return ResolverBuilder
53	*/
54	public function create(): ResolverBuilder
55	{
56	return new ResolverBuilder($this->extractorBuilderFactory);	×
57	}
58
59	/**
60	* @param ResolverBuilder $resolverBuilder
61	* @return ResolverBuilder
62	*/
63	public function compose(ResolverBuilder $resolverBuilder): ResolverBuilder
64	{
65	return new ResolverBuilder($this->extractorBuilderFactory, $resolverBuilder);	×
66	}
67
68	/**
69	* @param string $propertyName
70	* @param string ...$propertyNames
71	* @return ResolverBuilder
72	*/
73	public function get(string $propertyName, ...$propertyNames): ResolverBuilder
74	{
75	return $this->create()->get($propertyName, ...$propertyNames);	×
76	}
77
78	/**
79	* @param PredicateBuilderInterface $predicateBuilder
80	* @return ResolverBuilder
81	*/
82	public function filter(PredicateBuilderInterface $predicateBuilder): ResolverBuilder
83	{
84	return $this->create()->filter($predicateBuilder);	×
85	}
86
87	/**
88	* @param ResolverBuilder $resolverBuilder
89	* @return ResolverBuilder
90	*/
91	public function flatten(ResolverBuilder $resolverBuilder): ResolverBuilder
92	{
93	return $this->create()->flatten($resolverBuilder);	×
94	}
95
96	/**
97	* @param PredicateBuilderInterface $predicateBuilder
98	* @return ResolverBuilder
99	*/
100	public function find(PredicateBuilderInterface $predicateBuilder): ResolverBuilder
101	{
102	return $this->create()->find($predicateBuilder);	×
103	}
104
105	/**
106	* @param PredicateBuilderInterface $predicateBuilder
107	* @return Resolver
108	*/
109	public function all(PredicateBuilderInterface $predicateBuilder): Resolver
110	{
111	return $this->create()->all($predicateBuilder);	×
112	}
113
114	/**
115	* @param PredicateBuilderInterface $predicateBuilder
116	* @return Resolver
117	*/
118	public function none(PredicateBuilderInterface $predicateBuilder): Resolver
119	{
120	return $this->create()->none($predicateBuilder);	×
121	}
122
123	/**
124	* @param PredicateBuilderInterface $predicateBuilder
125	* @return Resolver
126	*/
127	public function some(PredicateBuilderInterface $predicateBuilder): Resolver
128	{
129	return $this->create()->some($predicateBuilder);	×
130	}
131
132	/**
133	* @return Resolver
134	*/
135	public function count(): Resolver
136	{
137	return $this->create()->count();	×
138	}
139
140	/**
141	* @return Resolver
142	*/
143	public function strlen(): Resolver
144	{
145	return $this->create()->strlen();	×
146	}
147
148	/**
149	* @param string $propertyName
150	* @return Resolver
151	*/
152	public function hasProperty(string $propertyName): Resolver
153	{
154	return $this->create()->hasProperty($propertyName);	×
155	}
156
157	/**
158	* @param string\|ResolverBuilder\|null $arg
159	* @return ExtractorPredicateBuilder
160	* @throws FactoryException
161	*/
162	public function where($arg = null): ExtractorPredicateBuilder
163	{
164	if (null === $arg) {	×
165	return $this->predicateBuilderFactory->getExtractorPredicateBuilder(	×
166	$this->extractorBuilderFactory->getResolverExtractorBuilder($this->create())	×
167	);	×
168	}
169
170	if (is_string($arg)) {	×
171	return $this->getExtractorPredicateBuilderForPropertyName($arg);	×
172	}
173
174	if ($arg instanceof ResolverBuilder) {	×
175	return $this->predicateBuilderFactory->getExtractorPredicateBuilder(	×
176	$this->extractorBuilderFactory->getResolverExtractorBuilder($arg)	×
177	);	×
178	}
179
180	throw new FactoryException(sprintf(	×
181	'Invalid argument given for method `where`, should be of type string or an instance of %s',	×
182	ResolverBuilder::class	×
183	));	×
184	}
185
186	/**
187	* @param PredicateBuilderInterface $predicateBuilder
188	* @return NotPredicateBuilder
189	*/
190	public function not(PredicateBuilderInterface $predicateBuilder): NotPredicateBuilder
191	{
192	return $this->predicateBuilderFactory->getNotPredicateBuilder($predicateBuilder);	×
193	}
194
195	/**
196	* @param PredicateBuilderInterface $leftPredicateBuilder
197	* @param PredicateBuilderInterface $rightPredicateBuilder
198	* @return OrPredicateBuilder
199	*/
200	public function or(
201	PredicateBuilderInterface $leftPredicateBuilder,
202	PredicateBuilderInterface $rightPredicateBuilder
203	): OrPredicateBuilder {
204	return $this->predicateBuilderFactory->getOrPredicateBuilder($leftPredicateBuilder, $rightPredicateBuilder);	×
205	}
206
207	/**
208	* @param PredicateBuilderInterface $leftPredicateBuilder
209	* @param PredicateBuilderInterface $rightPredicateBuilder
210	* @return AndPredicateBuilder
211	*/
212	public function and(
213	PredicateBuilderInterface $leftPredicateBuilder,
214	PredicateBuilderInterface $rightPredicateBuilder
215	): AndPredicateBuilder {
216	return $this->predicateBuilderFactory->getAndPredicateBuilder($leftPredicateBuilder, $rightPredicateBuilder);	×
217	}
218
219	/**
220	* @param string $propertyName
221	* @return ExtractorPredicateBuilder
222	*/
223	private function getExtractorPredicateBuilderForPropertyName(string $propertyName): ExtractorPredicateBuilder
224	{
225	$propertyName = trim($propertyName, '.');	×
226	if (false === strpos($propertyName, '.')) {	×
227	return $this->predicateBuilderFactory->getExtractorPredicateBuilder(	×
228	$this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)	×
229	);	×
230	}
231
232	return $this->getExtractorPredicateBuilderForPropertyNames(explode('.', $propertyName));	×
233	}
234
235	/**
236	* @param string[] $propertyNames
237	* @return ExtractorPredicateBuilder
238	*/
239	private function getExtractorPredicateBuilderForPropertyNames(array $propertyNames): ExtractorPredicateBuilder
240	{
241	$extractorBuilder = $this->extractorBuilderFactory->getCompositeExtractorBuilder(	×
242	$this->extractorBuilderFactory->getPropertyExtractorBuilder(array_shift($propertyNames)),	×
243	$this->extractorBuilderFactory->getPropertyExtractorBuilder(array_shift($propertyNames))	×
244	);	×
245
246	foreach ($propertyNames as $propertyName) {	×
247	$extractorBuilder = $this->extractorBuilderFactory->getCompositeExtractorBuilder(	×
248	$extractorBuilder,	×
249	$this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)	×
250	);	×
251	}
252
253	return $this->predicateBuilderFactory->getExtractorPredicateBuilder($extractorBuilder);	×
254	}
255	}

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