20366046645

Committed 19 Dec 2025 09:39AM UTC coverage: 52.497% (+0.2%) from 52.304%

Build # 20366046645

Build Type

push

github

Committed by

jojo1981

Commit Message

Fix: Upgrade dependencies to use the newest versions. Closes #4

Coverage Stats

8 of 12 new or added lines in 8 files covered. (66.67%)

452 of 861 relevant lines covered (52.5%)

8.33 hits per line

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

0.0

/src/Factory/ResolverBuilderFactory.php

<?php
/*
 * 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
 */
declare(strict_types=1);

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\Resolver;
use function array_shift;
use function explode;
use function is_string;
use function str_contains;
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
     */
    public function where(string|ResolverBuilder|null $arg = null): ExtractorPredicateBuilder
    {
        if (null === $arg) {
            return $this->predicateBuilderFactory->getExtractorPredicateBuilder(
                $this->extractorBuilderFactory->getResolverExtractorBuilder($this->create())
            );
        }

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

        return $this->predicateBuilderFactory->getExtractorPredicateBuilder(
            $this->extractorBuilderFactory->getResolverExtractorBuilder($arg)
        );
    }

    /**
     * @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 (!str_contains($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
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	declare(strict_types=1);
11
12	namespace Jojo1981\DataResolver\Factory;
13
14	use Jojo1981\DataResolver\Builder\Predicate\AndPredicateBuilder;
15	use Jojo1981\DataResolver\Builder\Predicate\ExtractorPredicateBuilder;
16	use Jojo1981\DataResolver\Builder\Predicate\NotPredicateBuilder;
17	use Jojo1981\DataResolver\Builder\Predicate\OrPredicateBuilder;
18	use Jojo1981\DataResolver\Builder\PredicateBuilderInterface;
19	use Jojo1981\DataResolver\Builder\ResolverBuilder;
20	use Jojo1981\DataResolver\Resolver;
21	use function array_shift;
22	use function explode;
23	use function is_string;
24	use function str_contains;
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	*/
161	public function where(string\|ResolverBuilder\|null $arg = null): ExtractorPredicateBuilder
162	{
163	if (null === $arg) {	×
164	return $this->predicateBuilderFactory->getExtractorPredicateBuilder(	×
165	$this->extractorBuilderFactory->getResolverExtractorBuilder($this->create())	×
166	);	×
167	}
168
169	if (is_string($arg)) {	×
170	return $this->getExtractorPredicateBuilderForPropertyName($arg);	×
171	}
172
NEW 173	return $this->predicateBuilderFactory->getExtractorPredicateBuilder(	×
NEW 174	$this->extractorBuilderFactory->getResolverExtractorBuilder($arg)	×
NEW 175	);	×
176	}
177
178	/**
179	* @param PredicateBuilderInterface $predicateBuilder
180	* @return NotPredicateBuilder
181	*/
182	public function not(PredicateBuilderInterface $predicateBuilder): NotPredicateBuilder
183	{
184	return $this->predicateBuilderFactory->getNotPredicateBuilder($predicateBuilder);	×
185	}
186
187	/**
188	* @param PredicateBuilderInterface $leftPredicateBuilder
189	* @param PredicateBuilderInterface $rightPredicateBuilder
190	* @return OrPredicateBuilder
191	*/
192	public function or(
193	PredicateBuilderInterface $leftPredicateBuilder,
194	PredicateBuilderInterface $rightPredicateBuilder
195	): OrPredicateBuilder {
196	return $this->predicateBuilderFactory->getOrPredicateBuilder($leftPredicateBuilder, $rightPredicateBuilder);	×
197	}
198
199	/**
200	* @param PredicateBuilderInterface $leftPredicateBuilder
201	* @param PredicateBuilderInterface $rightPredicateBuilder
202	* @return AndPredicateBuilder
203	*/
204	public function and(
205	PredicateBuilderInterface $leftPredicateBuilder,
206	PredicateBuilderInterface $rightPredicateBuilder
207	): AndPredicateBuilder {
208	return $this->predicateBuilderFactory->getAndPredicateBuilder($leftPredicateBuilder, $rightPredicateBuilder);	×
209	}
210
211	/**
212	* @param string $propertyName
213	* @return ExtractorPredicateBuilder
214	*/
215	private function getExtractorPredicateBuilderForPropertyName(string $propertyName): ExtractorPredicateBuilder
216	{
217	$propertyName = trim($propertyName, '.');	×
NEW 218	if (!str_contains($propertyName, '.')) {	×
219	return $this->predicateBuilderFactory->getExtractorPredicateBuilder(	×
220	$this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)	×
221	);	×
222	}
223
224	return $this->getExtractorPredicateBuilderForPropertyNames(explode('.', $propertyName));	×
225	}
226
227	/**
228	* @param string[] $propertyNames
229	* @return ExtractorPredicateBuilder
230	*/
231	private function getExtractorPredicateBuilderForPropertyNames(array $propertyNames): ExtractorPredicateBuilder
232	{
233	$extractorBuilder = $this->extractorBuilderFactory->getCompositeExtractorBuilder(	×
234	$this->extractorBuilderFactory->getPropertyExtractorBuilder(array_shift($propertyNames)),	×
235	$this->extractorBuilderFactory->getPropertyExtractorBuilder(array_shift($propertyNames))	×
236	);	×
237
238	foreach ($propertyNames as $propertyName) {	×
239	$extractorBuilder = $this->extractorBuilderFactory->getCompositeExtractorBuilder(	×
240	$extractorBuilder,	×
241	$this->extractorBuilderFactory->getPropertyExtractorBuilder($propertyName)	×
242	);	×
243	}
244
245	return $this->predicateBuilderFactory->getExtractorPredicateBuilder($extractorBuilder);	×
246	}
247	}

jojo1981 / data-resolver / 20366046645

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