Rename DragonCode\SizeSorter\Sorter with DragonCode\SizeSorter\SizeSorter

Author: andrey-helldar

README.md

@@ -39,9 +39,9 @@ When calling a sort with common values, each element will be assigned to one of
 5. Other values
 
 ```php
-use DragonCode\SizeSorter\Sorter;
+use DragonCode\SizeSorter\SizeSorter;
 
-return new Sorter([
+return new SizeSorter([
     'XXL',
     '26',
     '28',
@@ -69,23 +69,23 @@ return new Sorter([
 ```
 
 ```php
-use DragonCode\SizeSorter\Sorter;
+use DragonCode\SizeSorter\SizeSorter;
 
 // Laravel models collection
 $items = Size::query()->get();
 
-return new Sorter($items)
+return new SizeSorter($items)
     ->column('title')
     ->sort();
 ```
 
 ```php
-use DragonCode\SizeSorter\Sorter;
+use DragonCode\SizeSorter\SizeSorter;
 
 // Laravel collection
 $items = collect([...]);
 
-return new Sorter($items)
+return new SizeSorter($items)
     ->sort();
 
 /*
@@ -111,16 +111,10 @@ But you can change the order by specifying identifiers as the third parameter:
 
 ```php
 use DragonCode\SizeSorter\Enum\Group;
-use DragonCode\SizeSorter\Sorter;
+use DragonCode\SizeSorter\SizeSorter;
 
-return new Sorter($items)
-    ->groupsOrder([3, 5, 4, 2, 1])
-    ->sort();
-
-// or
-
-return new Sorter($items)
-    ->groupsOrder([
+return new SizeSorter($items)
+    ->orderBy([
         Group::BraSize,
         Group::OtherSizes,
         Group::OverallDimensions,
@@ -140,16 +134,10 @@ You can also specify some groups. For example:
 
 ```php
 use DragonCode\SizeSorter\Enum\Group;
-use DragonCode\SizeSorter\Sorter;
-
-return new Sorter($items)
-    ->groupsOrder([3, 5])
-    ->sort();
-
-// or
+use DragonCode\SizeSorter\SizeSorter;
 
-return new Sorter($items)
-    ->groupsOrder([Group::BraSize, Group::OtherSizes])
+return new SizeSorter($items)
+    ->orderBy([Group::BraSize, Group::OtherSizes])
     ->sort();
 ```
 

src/Services/MainLogic.php

@@ -14,7 +14,7 @@ class MainLogic
     public static function sort(iterable $items, string $column = 'value', ?array $groupsOrder = null): IC
     {
         return static::flatten(
-            static::handle(collect($items), $column, Order::resolve($groupsOrder))
+            static::handle(collect($items), $column, $groupsOrder)
         );
     }
 

src/Services/Order.php

@@ -8,38 +8,38 @@
 
 class Order
 {
-    public static function resolve(?array $groups): array
+    public function resolve(?array $groups = null): array
     {
         return ! empty($groups)
-            ? static::fill($groups)
-            : static::groups();
+            ? $this->fill($groups)
+            : $this->groups();
     }
 
-    protected static function fill(array $groups): array
+    protected function fill(array $groups): array
     {
-        return static::fillDefault(
-            static::fillCustom($groups)
+        return $this->fillDefault(
+            $this->fillCustom($groups)
         );
     }
 
-    protected static function fillCustom(array $groups): array
+    protected function fillCustom(array $groups): array
     {
         $result = [];
 
         foreach ($groups as $group) {
-            $value = static::resolveValue($group);
+            $value = $this->resolveValue($group);
 
-            if (static::existGroup($value)) {
+            if ($this->existGroup($value)) {
                 $result[] = $value;
             }
         }
 
         return $result;
     }
 
-    protected static function fillDefault(array $groups): array
+    protected function fillDefault(array $groups): array
     {
-        foreach (static::groups() as $group) {
+        foreach ($this->groups() as $group) {
             if (! in_array($group, $groups)) {
                 $groups[] = $group;
             }
@@ -48,20 +48,20 @@ protected static function fillDefault(array $groups): array
         return $groups;
     }
 
-    protected static function existGroup(int $value): bool
+    protected function existGroup(int $value): bool
     {
         return Group::exists($value);
     }
 
     /**
      * @return array<Group>
      */
-    protected static function groups(): array
+    protected function groups(): array
     {
         return Group::values();
     }
 
-    protected static function resolveValue(Group|int $group): int
+    protected function resolveValue(Group|int $group): int
     {
         return $group->value ?? $group;
     }

src/Sorter.php src/SizeSorter.phpsrc/Sorter.php renamed to src/SizeSorter.php

@@ -6,20 +6,23 @@
 
 use DragonCode\SizeSorter\Enum\Group;
 use DragonCode\SizeSorter\Services\MainLogic;
+use DragonCode\SizeSorter\Services\Order;
+use Illuminate\Support\Collection;
 
-class Sorter
+class SizeSorter
 {
     protected string $column = 'value';
 
-    protected ?array $groupsOrder = null;
+    protected ?array $orderBy = null;
 
-    public static function same(iterable $items): static
+    public static function items(iterable $items): static
     {
         return new static($items);
     }
 
     public function __construct(
-        protected readonly iterable $items
+        protected readonly iterable $items,
+        protected readonly Order $order = new Order
     ) {}
 
     public function column(string $name): static
@@ -33,15 +36,22 @@ public function column(string $name): static
      * @param  Group[]|null  $order
      * @return $this
      */
-    public function groupsOrder(?array $order): static
+    public function orderBy(?array $order): static
     {
-        $this->groupsOrder = $order;
+        (new Collection($order))->ensure(Group::class);
+
+        $this->orderBy = $this->order->resolve($order);
 
         return $this;
     }
 
     public function sort(): iterable
     {
-        return MainLogic::sort($this->items, $this->column, $this->groupsOrder);
+        return MainLogic::sort($this->items, $this->column, $this->getOrderBy());
+    }
+
+    protected function getOrderBy(): ?array
+    {
+        return $this->orderBy ?? $this->order->resolve();
     }
 }

tests/Sorters/SortTest.php

@@ -5,7 +5,7 @@
 namespace Tests\Sorters;
 
 use DragonCode\SizeSorter\Enum\Group;
-use DragonCode\SizeSorter\Sorter;
+use DragonCode\SizeSorter\SizeSorter;
 use PHPUnit\Framework\Attributes\DataProvider;
 use Tests\TestCase;
 
@@ -14,8 +14,8 @@ class SortTest extends TestCase
     #[DataProvider('sorterData')]
     public function testArray(?array $order, array $expected): void
     {
-        $actual = Sorter::same($this->values)
-            ->groupsOrder($order)
+        $actual = SizeSorter::items($this->values)
+            ->orderBy($order)
             ->sort()
             ->toArray();
 
@@ -31,8 +31,8 @@ public function testObjects(?array $order, array $expected): void
             'active' => true,
         ]);
 
-        $actual = Sorter::same($items)
-            ->groupsOrder($order)
+        $actual = SizeSorter::items($items)
+            ->orderBy($order)
             ->sort()
             ->pluck('value', 'id')
             ->toArray();
@@ -48,8 +48,8 @@ public function testCustomColumn(?array $order, array $expected): void
             'some' => $value,
         ]);
 
-        $actual = Sorter::same($items)
-            ->groupsOrder($order)
+        $actual = SizeSorter::items($items)
+            ->orderBy($order)
             ->column('some')
             ->sort()
             ->pluck('some', 'id')
@@ -71,8 +71,8 @@ public function testWithSaveKeys(?array $order, array $expected): void
             840 => 'XL',
         ];
 
-        $actual = Sorter::same($values)
-            ->groupsOrder($order)
+        $actual = SizeSorter::items($values)
+            ->orderBy($order)
             ->sort()
             ->toArray();
 

tests/Sorters/TypeTest.php

@@ -4,7 +4,7 @@
 
 namespace Tests\Sorters;
 
-use DragonCode\SizeSorter\Sorter;
+use DragonCode\SizeSorter\SizeSorter;
 use Illuminate\Database\Eloquent\Collection;
 use Tests\Fixtures\Enums\IntegerValue;
 use Tests\Fixtures\Enums\StringValue;
@@ -63,7 +63,7 @@ public function testString(): void
                 104 => 'ONE SIZE',
                 131 => 'some',
             ],
-            Sorter::same($items)->sort()->toArray()
+            SizeSorter::items($items)->sort()->toArray()
         );
     }
 
@@ -116,7 +116,7 @@ public function testStringable(): void
                 104 => $items[104],
                 131 => $items[131],
             ],
-            Sorter::same($items)->sort()->toArray()
+            SizeSorter::items($items)->sort()->toArray()
         );
     }
 
@@ -139,7 +139,7 @@ public function testInteger(): void
                 149 => 21,
                 133 => 30,
             ],
-            Sorter::same($items)->sort()->toArray()
+            SizeSorter::items($items)->sort()->toArray()
         );
     }
 
@@ -162,7 +162,7 @@ public function testFloat(): void
                 149 => 21.8,
                 133 => 30.5,
             ],
-            Sorter::same($items)->sort()->toArray()
+            SizeSorter::items($items)->sort()->toArray()
         );
     }
 
@@ -213,7 +213,7 @@ public function testEnumString(): void
                 104 => StringValue::VALUE_ONE_SIZE,
                 131 => StringValue::VALUE_SOME,
             ],
-            Sorter::same($items)->sort()->toArray()
+            SizeSorter::items($items)->sort()->toArray()
         );
     }
 
@@ -236,7 +236,7 @@ public function testEnumInteger(): void
                 149 => IntegerValue::VALUE_21,
                 133 => IntegerValue::VALUE_30,
             ],
-            Sorter::same($items)->sort()->toArray()
+            SizeSorter::items($items)->sort()->toArray()
         );
     }
 
@@ -289,7 +289,7 @@ public function testNestedArray(): void
                 104 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'ONE SIZE']]],
                 131 => ['foo' => 'Foo', 'bar' => ['some' => ['nested' => 'some']]],
             ],
-            Sorter::same($items)->column('bar.some.nested')->sort()->toArray()
+            SizeSorter::items($items)->column('bar.some.nested')->sort()->toArray()
         );
     }
 
@@ -344,7 +344,7 @@ public function testLaravelModels(): void
                 104 => 'ONE SIZE',
                 131 => 'some',
             ],
-            Sorter::same($items)->sort()->pluck('value', 'id')->toArray()
+            SizeSorter::items($items)->sort()->pluck('value', 'id')->toArray()
         );
     }
 
@@ -397,7 +397,7 @@ public function testCollection(): void
                 104 => 'ONE SIZE',
                 131 => 'some',
             ],
-            Sorter::same($items)->sort()->toArray()
+            SizeSorter::items($items)->sort()->toArray()
         );
     }
 }