Builder::create() - Code Metrics - Inspection of "Create named constructor for Builder" - SenseException/intl-sort - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1067a4...400d94 )

by Claudio

created 2022-08-01 21:31 UTC

Builder::create() A

↳ Parent: Builder

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Budgegeria\IntlSort;

use Budgegeria\IntlSort\Collator\ConfigurableCollator;
use Budgegeria\IntlSort\Collator\Configuration;
use Budgegeria\IntlSort\Comparator\Comparable;
use Budgegeria\IntlSort\ComparatorFactory\Factory;
use Budgegeria\IntlSort\ComparatorFactory\Standard;
use Budgegeria\IntlSort\ComparatorFactory\ValueObject;
use Budgegeria\IntlSort\Sorter\Asc;
use Budgegeria\IntlSort\Sorter\Desc;
use Budgegeria\IntlSort\Sorter\Key;
use Budgegeria\IntlSort\Sorter\Sorter;
use Collator;

class Builder
{
    private Collator $collator;

    private bool $isAsc = true;

    private bool $isKeySort = false;

    private Factory $comparatorFactory;

    private Configuration $configuration;

    public function __construct(string $locale, ?Factory $comparatorFactory = null)
    {
        $this->collator          = new Collator($locale);
        $this->configuration     = new Configuration();
        $this->comparatorFactory = $comparatorFactory ?? new Standard();
    }

    public static function create(string $locale): self
    {
        return new self($locale, new Standard());
    }

    public function enableFrenchCollation(): self
    {
        $this->collator->setAttribute(Collator::FRENCH_COLLATION, Collator::ON);

        return $this;
    }

    public function disableFrenchCollation(): self
    {
        $this->collator->setAttribute(Collator::FRENCH_COLLATION, Collator::OFF);

        return $this;
    }

    public function lowerCaseFirst(): self
    {
        $this->collator->setAttribute(Collator::CASE_FIRST, Collator::LOWER_FIRST);

        return $this;
    }

    public function upperCaseFirst(): self
    {
        $this->collator->setAttribute(Collator::CASE_FIRST, Collator::UPPER_FIRST);

        return $this;
    }

    public function removeCaseFirst(): self
    {
        $this->collator->setAttribute(Collator::CASE_FIRST, Collator::OFF);

        return $this;
    }

    public function enableNormalizationMode(): self
    {
        $this->collator->setAttribute(Collator::NORMALIZATION_MODE, Collator::ON);

        return $this;
    }

    public function disableNormalizationMode(): self
    {
        $this->collator->setAttribute(Collator::NORMALIZATION_MODE, Collator::OFF);

        return $this;
    }

    public function enableNumericCollation(): self
    {
        $this->collator->setAttribute(Collator::NUMERIC_COLLATION, Collator::ON);

        return $this;
    }

    public function disableNumericCollation(): self
    {
        $this->collator->setAttribute(Collator::NUMERIC_COLLATION, Collator::OFF);

        return $this;
    }

    public function enableCaseLevel(): self
    {
        $this->collator->setAttribute(Collator::CASE_LEVEL, Collator::ON);

        return $this;
    }

    public function disableCaseLevel(): self
    {
        $this->collator->setAttribute(Collator::CASE_LEVEL, Collator::OFF);

        return $this;
    }

    public function nonIgnorableAlternateHandling(): self
    {
        $this->collator->setAttribute(Collator::ALTERNATE_HANDLING, Collator::NON_IGNORABLE);

        return $this;
    }

    public function shiftedAlternateHandling(): self
    {
        $this->collator->setAttribute(Collator::ALTERNATE_HANDLING, Collator::SHIFTED);

        return $this;
    }

    /**
     * Ignore accents and case
     */
    public function primaryStrength(): self
    {
        $this->collator->setStrength(Collator::PRIMARY);

        return $this;
    }

    /**
     * Ignore case, consider accents
     */
    public function secondaryStrength(): self
    {
        $this->collator->setStrength(Collator::SECONDARY);

        return $this;
    }

    /**
     * Consider accents and case
     */
    public function tertiaryStrength(): self
    {
        $this->collator->setStrength(Collator::TERTIARY);

        return $this;
    }

    /**
     * Like tertiary, but also considers whitespace, punctuation, and symbols differently when
     * used with {@see shiftedAlternateHandling()}
     */
    public function quaternaryStrength(): self
    {
        $this->collator->setStrength(Collator::QUATERNARY);

        return $this;
    }

    public function identicalStrength(): self
    {
        $this->collator->setStrength(Collator::IDENTICAL);

        return $this;
    }

    public function orderByAsc(): self
    {
        $this->isAsc = true;

        return $this;
    }

    public function orderByDesc(): self
    {
        $this->isAsc = false;

        return $this;
    }

    public function orderByKeys(): self
    {
        $this->isKeySort = true;

        return $this;
    }

    public function orderByValues(): self
    {
        $this->isKeySort = false;

        return $this;
    }

    public function nullFirst(): self
    {
        $this->configuration->setNullableSort(Configuration::NULL_VALUES_FIRST);

        return $this;
    }

    public function nullLast(): self
    {
        $this->configuration->setNullableSort(Configuration::NULL_VALUES_LAST);

        return $this;
    }

    public function removeNullPosition(): self
    {
        $this->configuration->setNullableSort(null);

        return $this;
    }

    public function getSorter(): Sorter
    {
        $comparator = $this->getComparator();
        if ($this->isKeySort) {
            $sorter = new Key($comparator);
        } else {
            $sorter = new Asc($comparator);
        }

        if (! $this->isAsc) {
            return new Desc($sorter);
        }

        return $sorter;
    }

    public function getComparator(): Comparable
    {
        return $this->comparatorFactory->create(new ConfigurableCollator($this->collator, $this->configuration));
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Budgegeria\IntlSort;
6
7		use Budgegeria\IntlSort\Collator\ConfigurableCollator;
8		use Budgegeria\IntlSort\Collator\Configuration;
9		use Budgegeria\IntlSort\Comparator\Comparable;
10		use Budgegeria\IntlSort\ComparatorFactory\Factory;
11		use Budgegeria\IntlSort\ComparatorFactory\Standard;
12		use Budgegeria\IntlSort\ComparatorFactory\ValueObject;
13		use Budgegeria\IntlSort\Sorter\Asc;
14		use Budgegeria\IntlSort\Sorter\Desc;
15		use Budgegeria\IntlSort\Sorter\Key;
16		use Budgegeria\IntlSort\Sorter\Sorter;
17		use Collator;
18
19		class Builder
20		{
21		private Collator $collator;
22
23		private bool $isAsc = true;
24
25		private bool $isKeySort = false;
26
27		private Factory $comparatorFactory;
28
29		private Configuration $configuration;
30
31	38	public function __construct(string $locale, ?Factory $comparatorFactory = null)
32		{
33	38	$this->collator = new Collator($locale);
34	38	$this->configuration = new Configuration();
35	38	$this->comparatorFactory = $comparatorFactory ?? new Standard();
36		}
37
38	38	public static function create(string $locale): self
39		{
40	38	return new self($locale, new Standard());
41		}
42
43	2	public function enableFrenchCollation(): self
44		{
45	2	$this->collator->setAttribute(Collator::FRENCH_COLLATION, Collator::ON);
46
47	2	return $this;
48		}
49
50	1	public function disableFrenchCollation(): self
51		{
52	1	$this->collator->setAttribute(Collator::FRENCH_COLLATION, Collator::OFF);
53
54	1	return $this;
55		}
56
57	1	public function lowerCaseFirst(): self
58		{
59	1	$this->collator->setAttribute(Collator::CASE_FIRST, Collator::LOWER_FIRST);
60
61	1	return $this;
62		}
63
64	3	public function upperCaseFirst(): self
65		{
66	3	$this->collator->setAttribute(Collator::CASE_FIRST, Collator::UPPER_FIRST);
67
68	3	return $this;
69		}
70
71	1	public function removeCaseFirst(): self
72		{
73	1	$this->collator->setAttribute(Collator::CASE_FIRST, Collator::OFF);
74
75	1	return $this;
76		}
77
78	2	public function enableNormalizationMode(): self
79		{
80	2	$this->collator->setAttribute(Collator::NORMALIZATION_MODE, Collator::ON);
81
82	2	return $this;
83		}
84
85	1	public function disableNormalizationMode(): self
86		{
87	1	$this->collator->setAttribute(Collator::NORMALIZATION_MODE, Collator::OFF);
88
89	1	return $this;
90		}
91
92	2	public function enableNumericCollation(): self
93		{
94	2	$this->collator->setAttribute(Collator::NUMERIC_COLLATION, Collator::ON);
95
96	2	return $this;
97		}
98
99	1	public function disableNumericCollation(): self
100		{
101	1	$this->collator->setAttribute(Collator::NUMERIC_COLLATION, Collator::OFF);
102
103	1	return $this;
104		}
105
106	3	public function enableCaseLevel(): self
107		{
108	3	$this->collator->setAttribute(Collator::CASE_LEVEL, Collator::ON);
109
110	3	return $this;
111		}
112
113	2	public function disableCaseLevel(): self
114		{
115	2	$this->collator->setAttribute(Collator::CASE_LEVEL, Collator::OFF);
116
117	2	return $this;
118		}
119
120	1	public function nonIgnorableAlternateHandling(): self
121		{
122	1	$this->collator->setAttribute(Collator::ALTERNATE_HANDLING, Collator::NON_IGNORABLE);
123
124	1	return $this;
125		}
126
127	4	public function shiftedAlternateHandling(): self
128		{
129	4	$this->collator->setAttribute(Collator::ALTERNATE_HANDLING, Collator::SHIFTED);
130
131	4	return $this;
132		}
133
134		/**
135		* Ignore accents and case
136		*/
137	5	public function primaryStrength(): self
138		{
139	5	$this->collator->setStrength(Collator::PRIMARY);
140
141	5	return $this;
142		}
143
144		/**
145		* Ignore case, consider accents
146		*/
147	2	public function secondaryStrength(): self
148		{
149	2	$this->collator->setStrength(Collator::SECONDARY);
150
151	2	return $this;
152		}
153
154		/**
155		* Consider accents and case
156		*/
157	3	public function tertiaryStrength(): self
158		{
159	3	$this->collator->setStrength(Collator::TERTIARY);
160
161	3	return $this;
162		}
163
164		/**
165		* Like tertiary, but also considers whitespace, punctuation, and symbols differently when
166		* used with {@see shiftedAlternateHandling()}
167		*/
168	2	public function quaternaryStrength(): self
169		{
170	2	$this->collator->setStrength(Collator::QUATERNARY);
171
172	2	return $this;
173		}
174
175	4	public function identicalStrength(): self
176		{
177	4	$this->collator->setStrength(Collator::IDENTICAL);
178
179	4	return $this;
180		}
181
182	1	public function orderByAsc(): self
183		{
184	1	$this->isAsc = true;
185
186	1	return $this;
187		}
188
189	4	public function orderByDesc(): self
190		{
191	4	$this->isAsc = false;
192
193	4	return $this;
194		}
195
196	3	public function orderByKeys(): self
197		{
198	3	$this->isKeySort = true;
199
200	3	return $this;
201		}
202
203	1	public function orderByValues(): self
204		{
205	1	$this->isKeySort = false;
206
207	1	return $this;
208		}
209
210	2	public function nullFirst(): self
211		{
212	2	$this->configuration->setNullableSort(Configuration::NULL_VALUES_FIRST);
213
214	2	return $this;
215		}
216
217	2	public function nullLast(): self
218		{
219	2	$this->configuration->setNullableSort(Configuration::NULL_VALUES_LAST);
220
221	2	return $this;
222		}
223
224	1	public function removeNullPosition(): self
225		{
226	1	$this->configuration->setNullableSort(null);
227
228	1	return $this;
229		}
230
231	36	public function getSorter(): Sorter
232		{
233	36	$comparator = $this->getComparator();
234	36	if ($this->isKeySort) {
235	2	$sorter = new Key($comparator);
236		} else {
237	34	$sorter = new Asc($comparator);
238		}
239
240	36	if (! $this->isAsc) {
241	3	return new Desc($sorter);
242		}
243
244	33	return $sorter;
245		}
246
247	38	public function getComparator(): Comparable
248		{
249	38	return $this->comparatorFactory->create(new ConfigurableCollator($this->collator, $this->configuration));
250		}
251		}
252

SenseException / intl-sort

Push — master ( 1067a4...400d94 )

Builder::create() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like