Improve Schema API and DateField API

Author: nyamsprod

src/Buffer.php

@@ -231,7 +231,7 @@ public function inferSchema(?Inspector $inspector = null, array $header = []): S
 
     public function inferRecords(?Inspector $inspector = null, array $header = []): Iterator
     {
-        return $this->inferSchema($inspector, $header)->parse($this, $header);
+        return $this->inferSchema($inspector, $header)->parse($this);
     }
 
     /**

src/Reader.php

@@ -425,7 +425,7 @@ public function inferSchema(?Inspector $inspector = null, array $header = []): S
 
     public function inferRecords(?Inspector $inspector = null, array $header = []): Iterator
     {
-        return $this->inferSchema($inspector, $header)->parse($this, $header);
+        return $this->inferSchema($inspector, $header)->parse($this);
     }
 
     /**

src/ResultSet.php

@@ -215,7 +215,7 @@ public function inferSchema(?Inspector $inspector = null, array $header = []): S
 
     public function inferRecords(?Inspector $inspector = null, array $header = []): Iterator
     {
-        return $this->inferSchema($inspector, $header)->parse($this, $header);
+        return $this->inferSchema($inspector, $header)->parse($this);
     }
 
     /**

src/Schema/FieldList.php

@@ -45,7 +45,7 @@ public static function default(): self
             new DateField(format: 'd/m/Y'),
             new DateField(format: 'Y-m-d H:i:s'),
             new JsonField(),
-            RegexpField::uuid(),
+            StructuredStringField::uuid(),
         );
     }
 

src/Schema/Schema.php

@@ -20,6 +20,8 @@
 use League\Csv\TabularData;
 use ValueError;
 
+use function array_diff_key;
+use function array_flip;
 use function array_key_exists;
 use function array_keys;
 use function array_map;
@@ -44,6 +46,30 @@ public function __construct(iterable $fields = [])
         $this->fields = $newFields;
     }
 
+    public function append(int|string $name, Field $field): self
+    {
+        self::assertNoDuplicate($this->fields, $name);
+
+        return new self([...$this->fields, ...[$name => $field]]);
+    }
+
+    public function replace(int|string $name, Field $field): self
+    {
+        $this->has($name) || throw new ValueError('Field "'.$name.'" does not exist.');
+
+        $fields = $this->fields;
+        $fields[$name] = $field;
+
+        return new self($fields);
+    }
+
+    public function remove(int|string ...$names): self
+    {
+        return [] === $names
+            ? $this
+            : new self(array_diff_key($this->fields, array_flip($names)));
+    }
+
     private static function assertNoDuplicate(array $data, string|int $key): void
     {
         ! array_key_exists($key, $data) || throw new ValueError('The key already exists: '.$key);
@@ -118,9 +144,9 @@ public function map(callable $callback): Iterator
     /**
      * @return Iterator<int, array<mixed>>
      */
-    public function parse(TabularData $tabularData, array $header = []): Iterator
+    public function parse(TabularData $tabularData): Iterator
     {
-        return MapIterator::fromIterable($tabularData->getRecords($header), $this->format(...));
+        return MapIterator::fromIterable($tabularData->getRecords($this->names()), $this->format(...));
     }
 
     public function format(array $row): array

src/Schema/RegexpField.php src/Schema/StructuredStringField.phpsrc/Schema/RegexpField.php renamed to src/Schema/StructuredStringField.php

@@ -17,13 +17,13 @@
 use function preg_match;
 use function trim;
 
-final class RegexpField extends AbstractField
+final class StructuredStringField extends AbstractField
 {
     /** @var non-empty-string */
     public readonly string $name;
     public readonly string $pattern;
 
-    public function __construct(RegexpFieldDefinition $definition)
+    public function __construct(StructuredStringFieldDefinition $definition)
     {
         parent::__construct($definition->confidenceThreshold);
 
@@ -33,32 +33,32 @@ public function __construct(RegexpFieldDefinition $definition)
 
     public static function uuid(float $confidenceThreshold = 0.8): self
     {
-        return new self(RegexpFieldDefinition::uuid($confidenceThreshold));
+        return new self(StructuredStringFieldDefinition::uuid($confidenceThreshold));
     }
 
     public static function ulid(float $confidenceThreshold = 0.8): self
     {
-        return new self(RegexpFieldDefinition::ulid($confidenceThreshold));
+        return new self(StructuredStringFieldDefinition::ulid($confidenceThreshold));
     }
 
     public static function hexColor(float $confidenceThreshold = 0.8): self
     {
-        return new self(RegexpFieldDefinition::hexColor($confidenceThreshold));
+        return new self(StructuredStringFieldDefinition::hexColor($confidenceThreshold));
     }
 
     public static function jwtToken(float $confidenceThreshold = 0.8): self
     {
-        return new self(RegexpFieldDefinition::jwtToken($confidenceThreshold));
+        return new self(StructuredStringFieldDefinition::jwtToken($confidenceThreshold));
     }
 
     public static function md5(float $confidenceThreshold = 0.8): self
     {
-        return new self(RegexpFieldDefinition::md5($confidenceThreshold));
+        return new self(StructuredStringFieldDefinition::md5($confidenceThreshold));
     }
 
     public static function sha1(float $confidenceThreshold = 0.8): self
     {
-        return new self(RegexpFieldDefinition::sha1($confidenceThreshold));
+        return new self(StructuredStringFieldDefinition::sha1($confidenceThreshold));
     }
 
     public function type(): FieldType

src/Schema/RegexpFieldDefinition.php …hema/StructuredStringFieldDefinition.phpsrc/Schema/RegexpFieldDefinition.php renamed to src/Schema/StructuredStringFieldDefinition.php src/Schema/RegexpFieldDefinition.php renamed to src/Schema/StructuredStringFieldDefinition.php

@@ -17,12 +17,12 @@
 
 use function preg_match;
 
-final readonly class RegexpFieldDefinition
+final readonly class StructuredStringFieldDefinition
 {
-    public string $pattern;
-    public float $confidenceThreshold;
     /** @var non-empty-string */
     public string $name;
+    public string $pattern;
+    public float $confidenceThreshold;
 
     public function __construct(
         string $name,
@@ -91,4 +91,11 @@ public static function sha1(float $confidenceThreshold = 0.8): self
             confidenceThreshold: $confidenceThreshold,
         );
     }
+
+    public function withConfidenceThreshold(float $confidenceThreshold): self
+    {
+        return $this->confidenceThreshold === $confidenceThreshold
+            ? $this
+            : new self(name: $this->name, pattern: $this->pattern, confidenceThreshold: $confidenceThreshold);
+    }
 }

src/Schema/RegexpFieldTest.php src/Schema/StructuredStringFieldTest.phpsrc/Schema/RegexpFieldTest.php renamed to src/Schema/StructuredStringFieldTest.php

@@ -17,16 +17,16 @@
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
-#[CoversClass(RegexpField::class)]
-final class RegexpFieldTest extends TestCase
+#[CoversClass(StructuredStringField::class)]
+final class StructuredStringFieldTest extends TestCase
 {
     // --------------------------------------------------------
     // Factory constructors
     // --------------------------------------------------------
 
     public function testUuidFactoryCreatesValidStrategy(): void
     {
-        $field = RegexpField::uuid();
+        $field = StructuredStringField::uuid();
 
         self::assertSame(FieldType::StructuredString, $field->type());
         self::assertSame('uuid', $field->name());
@@ -35,21 +35,21 @@ public function testUuidFactoryCreatesValidStrategy(): void
 
     public function testUlidFactoryCreatesValidStrategy(): void
     {
-        $field = RegexpField::ulid();
+        $field = StructuredStringField::ulid();
 
         self::assertSame('ulid', $field->name());
     }
 
     public function testHexColorFactoryCreatesValidStrategy(): void
     {
-        $field = RegexpField::hexColor();
+        $field = StructuredStringField::hexColor();
 
         self::assertSame('hex_color', $field->name());
     }
 
     public function testJwtTokenFactoryCreatesValidStrategy(): void
     {
-        $field = RegexpField::jwtToken();
+        $field = StructuredStringField::jwtToken();
 
         self::assertSame('jwt_token', $field->name());
     }
@@ -81,10 +81,10 @@ public function testParseValidValues(string $input, string $expected): void
     {
         // NOTE: we test multiple strategies explicitly because pattern differs
         $fields = [
-            RegexpField::uuid(),
-            RegexpField::ulid(),
-            RegexpField::hexColor(),
-            RegexpField::jwtToken(),
+            StructuredStringField::uuid(),
+            StructuredStringField::ulid(),
+            StructuredStringField::hexColor(),
+            StructuredStringField::jwtToken(),
         ];
 
         $matched = false;
@@ -118,7 +118,7 @@ public static function provideInvalidValues(): array
     #[DataProvider('provideInvalidValues')]
     public function testParseInvalidValues(mixed $input): void
     {
-        $field = RegexpField::uuid();
+        $field = StructuredStringField::uuid();
 
         self::assertNull($field->parse($input));
     }
@@ -129,7 +129,7 @@ public function testParseInvalidValues(mixed $input): void
 
     public function testParseTrimsInput(): void
     {
-        $field = RegexpField::uuid();
+        $field = StructuredStringField::uuid();
 
         $value = ' 550e8400-e29b-41d4-a716-446655440000 ';
 
@@ -145,7 +145,7 @@ public function testParseTrimsInput(): void
 
     public function testTypeMatchesDefinition(): void
     {
-        $field = RegexpField::hexColor();
+        $field = StructuredStringField::hexColor();
 
         self::assertSame(FieldType::StructuredString, $field->type());
     }