Feature: Add In, InStrict, and DateTime validation rules

src/Rules/DateTime.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace StellarWP\Validation\Rules;
+
+use Closure;
+use DateTimeImmutable;
+use DateTimeInterface;
+use Exception;
+use StellarWP\Validation\Contracts\Sanitizer;
+use StellarWP\Validation\Contracts\ValidatesOnFrontEnd;
+use StellarWP\Validation\Contracts\ValidationRule;
+
+/**
+ * This rule validates that the given value is a valid date.
+ *
+ * @unreleased
+ */
+class DateTime implements ValidationRule, ValidatesOnFrontEnd, Sanitizer
+{
+    /**
+     * @var string|null
+     */
+    protected $format;
+
+    /**
+     * @unreleased
+     */
+    public static function id(): string
+    {
+        return 'dateTime';
+    }
+
+    /**
+     * @unreleased
+     */
+    public static function fromString(string $options = null): ValidationRule
+    {
+        return new static($options);
+    }
+
+    /**
+     * @unreleased
+     */
+    public function __construct(string $format = null)
+    {
+        $this->format = $format;
+    }
+
+    /**
+     * @unreleased
+     */
+    public function __invoke($value, Closure $fail, string $key, array $values)
+    {
+        if ($value instanceof DateTimeInterface) {
+            return;
+        }
+
+        $failedValidation = function () use ($fail) {
+            $fail(sprintf(__('%s must be a valid date', '%TEXTDOMAIN%'), '{field}'));
+        };
+
+        try {
+            if (!is_string($value) && !is_numeric($value)) {
+                $failedValidation();
+
+                return;
+            }
+
+            if ($this->format !== null) {
+                $date = \DateTime::createFromFormat($this->format, $value);
+                if ($date === false || $date->format($this->format) !== $value) {
+                    $failedValidation();
+
+                    return;
+                }
+            }
+
+            if (strtotime($value) === false) {
+                $failedValidation();
+
+                return;
+            }
+        } catch (Exception $exception) {
+            $failedValidation();
+
+            return;
+        }
+
+        $date = date_parse($value);
+
+        if (!checkdate($date['month'], $date['day'], $date['year'])) {
+            $failedValidation();
+        }
+    }
+
+    /**
+     * @unreleased
+     */
+    public function sanitize($value)
+    {
+        if ($value instanceof DateTimeInterface) {
+            return $value;
+        }
+
+        if ($this->format !== null) {
+            return DateTimeImmutable::createFromFormat($this->format, $value);
+        }
+
+        return new DateTimeImmutable($value);
+    }
+
+    /**
+     * @unreleased
+     */
+    public function serializeOption()
+    {
+        return $this->format;
+    }
+
+}

src/Rules/In.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace StellarWP\Validation\Rules;
+
+use Closure;
+use StellarWP\Validation\Config;
+use StellarWP\Validation\Contracts\ValidatesOnFrontEnd;
+use StellarWP\Validation\Contracts\ValidationRule;
+
+class In implements ValidationRule, ValidatesOnFrontEnd
+{
+    /**
+     * @var array
+     */
+    protected $acceptedValues;
+
+    /**
+     * @unreleased
+     */
+    public static function id(): string
+    {
+        return 'in';
+    }
+
+    /**
+     * @unreleased
+     */
+    final public function __construct(...$acceptedValues)
+    {
+        if (empty($acceptedValues)) {
+            Config::throwInvalidArgumentException('The In rule requires at least one value to be specified.');
+        }
+
+        $this->acceptedValues = $acceptedValues;
+    }
+
+    /**
+     * @unreleased
+     */
+    public static function fromString(string $options = null): ValidationRule
+    {
+        if (empty(trim($options))) {
+            Config::throwInvalidArgumentException('The In rule requires at least one value to be specified.');
+        }
+
+        $values = explode(',', $options);
+
+        if (empty($values)) {
+            Config::throwInvalidArgumentException('The In rule requires at least one value to be specified.');
+        }
+
+        return new static(...$values);
+    }
+
+    /**
+     * @unreleased
+     */
+    public function __invoke($value, Closure $fail, string $key, array $values)
+    {
+        if (!in_array($value, $this->acceptedValues)) {
+            $fail(sprintf(__('%s must be one of %s', '%TEXTDOMAIN%'), '{field}', implode(', ', $this->acceptedValues)));
+        }
+    }
+
+    /**
+     * @unreleased
+     */
+    public function serializeOption(): array
+    {
+        return $this->acceptedValues;
+    }
+}

src/Rules/InStrict.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace StellarWP\Validation\Rules;
+
+use Closure;
+
+class InStrict extends In
+{
+    /**
+     * @unreleased
+     */
+    public static function id(): string
+    {
+        return 'inStrict';
+    }
+
+    /**
+     * @unreleased
+     */
+    public function __invoke($value, Closure $fail, string $key, array $values)
+    {
+        if (!in_array($value, $this->acceptedValues, true)) {
+            $fail(sprintf(__('%s must be one of %s', '%TEXTDOMAIN%'), '{field}', implode(', ', $this->acceptedValues)));
+        }
+    }
+}

src/ServiceProvider.php

@@ -5,10 +5,12 @@
 namespace StellarWP\Validation;
 
 use StellarWP\Validation\Rules\Currency;
+use StellarWP\Validation\Rules\DateTime;
 use StellarWP\Validation\Rules\Email;
 use StellarWP\Validation\Rules\Exclude;
 use StellarWP\Validation\Rules\ExcludeIf;
 use StellarWP\Validation\Rules\ExcludeUnless;
+use StellarWP\Validation\Rules\In;
 use StellarWP\Validation\Rules\Integer;
 use StellarWP\Validation\Rules\Max;
 use StellarWP\Validation\Rules\Min;
@@ -30,6 +32,7 @@ class ServiceProvider
         Max::class,
         Size::class,
         Numeric::class,
+        In::class,
         Integer::class,
         Email::class,
         Currency::class,
@@ -42,6 +45,7 @@ class ServiceProvider
         Optional::class,
         OptionalIf::class,
         OptionalUnless::class,
+        DateTime::class,
     ];
 
     /**

tests/unit/Rules/DateTimeTest.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace StellarWP\Validation\Tests\Unit\Rules;
+
+use DateTime;
+use DateTimeImmutable;
+use StellarWP\Validation\Rules\DateTime as DateTimeRule;
+use StellarWP\Validation\Tests\TestCase;
+
+class DateTimeTest extends TestCase
+{
+    /**
+     * @unreleased
+     */
+    public function testShouldPassDateTimeInstance()
+    {
+        $rule = new DateTimeRule();
+
+        $this->assertValidationRulePassed($rule, new DateTime());
+        $this->assertValidationRulePassed($rule, new DateTimeImmutable());
+    }
+
+    /**
+     * @unreleased
+     */
+    public function testShouldPassDateTimeString()
+    {
+        $rule = new DateTimeRule();
+
+        $this->assertValidationRulePassed($rule, '2018-01-01 00:00:00');
+        $this->assertValidationRulePassed($rule, '2018-01-01 00:00:00.000000');
+        $this->assertValidationRulePassed($rule, '2018-01-01T00:00:00+00:00');
+    }
+
+    /**
+     * @unreleased
+     */
+    public function testShouldFailRelativeDateTimeString()
+    {
+        $rule = new DateTimeRule();
+
+        $this->assertValidationRuleFailed($rule, 'now');
+        $this->assertValidationRuleFailed($rule, 'tomorrow');
+        $this->assertValidationRuleFailed($rule, 'yesterday');
+    }
+
+    /**
+     * @unreleased
+     */
+    public function testShouldFailInvalidDateTimeStringValues()
+    {
+        $rule = new DateTimeRule();
+
+        $this->assertValidationRuleFailed($rule, true);
+        $this->assertValidationRuleFailed($rule, []);
+        $this->assertValidationRuleFailed($rule, 'abc');
+    }
+
+    /**
+     * @unreleased
+     */
+    public function testShouldPassDateTimeStringWithFormat()
+    {
+        $rule = new DateTimeRule('Y-m-d H:i:s');
+
+        $this->assertValidationRulePassed($rule, '2018-01-01 00:00:00');
+        $this->assertValidationRuleFailed($rule, '2018-01-01 00:00:00.000000');
+        $this->assertValidationRuleFailed($rule, '2018-01-01T00:00:00+00:00');
+    }
+
+    /**
+     * @unreleased
+     */
+    public function testShouldReturnSameDateTimeInstanceWhenSanitizing()
+    {
+        $rule = new DateTimeRule();
+
+        $date = new DateTimeImmutable();
+        $this->assertSame($date, $rule->sanitize($date));
+    }
+
+    /**
+     * @unreleased
+     */
+    public function testShouldReturnDateTimeInstanceWhenSanitizingDateTimeString()
+    {
+        $rule = new DateTimeRule();
+
+        $date = new DateTimeImmutable();
+        $this->assertEquals(
+            $date->format('Y-m-d H:i:s'),
+            $rule->sanitize($date->format('Y-m-d H:i:s'))->format('Y-m-d H:i:s')
+        );
+    }
+}