dimtrovich / validation

src/Rules/Postalcode.php

<?php

/**
 * This file is part of Dimtrovich/Validation.
 *
 * (c) 2023 Dimitri Sitchet Tomkeu <devcode.dst@gmail.com>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace Dimtrovich\Validation\Rules;

use BlitzPHP\Utilities\Support\Invader;
use Rakit\Validation\Rule;

class Postalcode extends AbstractRule
{
    /**
     * Reference key to get locale from data
     */
    protected ?string $reference = null;

    protected array $countrycodes = [];

    /**
     * {@inheritDoc}
     */
    public function fillParameters(array $params): Rule
    {
        $this->countrycodes = $params;

        return $this;
    }

    /**
     * Static constructor method to create data aware validation rule which
     * reads the allowed country code by reference.
     */
    public static function reference(string $reference): static
    {
        $rule            = new static();
        $rule->reference = $reference;

        return $rule;
    }

    /**
     * Static constructor method
     */
    public static function countrycode(array $countrycodes): static
    {
        $rule               = new static();
        $rule->countrycodes = $countrycodes;

        return $rule;
    }

    /**
     * Check if the current value is a valid Postal Code
     *
     * @see https://en.wikipedia.org/wiki/Postal_code
     *
     * @credit <a href="https://github.com/Intervention/validation">Intervention/validation - \Intervention\Validation\Rules\PostalCode</a>
     *
     * @param mixed $value
     */
    public function check($value): bool
    {
        foreach ($this->getPatterns() as $pattern) {
            if (preg_match($pattern, $value)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Return regex patterns for allowed country codes
     */
    protected function getPatterns(): array
    {
        $patterns = array_map(fn ($countrycode) => $this->getPattern($countrycode), $this->getCountryCodes());

        return array_filter($patterns, fn ($pattern) => null !== $pattern);
    }

    protected function getCountryCodes(): array
    {
        if (count($this->countrycodes) === 0) {
            $data = Invader::make($this->validation)->inputs;

It seems like $this->validation can also be of type null; however, parameter $obj of BlitzPHP\Utilities\Support\Invader::make() does only seem to accept object, maybe add an additional type check?

            // return country code by reference
            if (is_array($data) && array_key_exists($this->reference, $data)) {
                return [$data[$this->reference]];
            }
        }

        return $this->countrycodes;
    }

    /**
     * Return regex pattern for postal code of current country code
     */
    protected function getPattern(string $countrycode): ?string
    {
        switch (strtolower($countrycode)) {
            case 'dz':
            case 'as':
            case 'ad':
            case 'de':
            case 'ba':
            case 'ic':
            case 'mp':
            case 'hr':
            case 'cu':
            case 'ee':
            case 'fi':
            case 'fr':
            case 'gf':
            case 'gp':
            case 'gu':
            case 'id':
            case 'it':
            case 'kr':
            case 'kv':
            case 'lt':
            case 'my':
            case 'mh':
            case 'mq':
            case 'yt':
            case 'fm':
            case 'mc':
            case 'me':
            case 'ma':
            case 'nc':
            case 'pk':
            case 'pw':
            case 'pr':
            case 're':
            case 'sm':
            case 'rs':
            case 'es':
            case 'xy':
            case 'th':
            case 'tr':
            case 'ua':
            case 'us':
            case 'vi':
                return '/^[0-9]{5}$/';

            case 'fo':
            case 'is':
            case 'mg':
            case 'pg':
                return '/^[0-9]{3}$/';

            case 'cz':
            case 'gr':
            case 'sk':
            case 'se':
                return '/^[0-9]{3} [0-9]{2}$/';

            case 'il':
                return '/^[0-9]{5}([0-9]{2})?$/';

            case 'br':
                return '/^[0-9]{5}(-?[0-9]{3})?$/';

            case 'gg':
            case 'je':
                return '/^[a-z]{2}[0-9][0-9]? [0-9][a-z]{2}$/i';

            case 'bn':
                return '/^[a-z]{2}[0-9]{4}$/i';

            case 'jp':
                return '/^[0-9]{3}-[0-9]{4}$/';

            case 'nl':
                return '/^[0-9]{4}\\s?[a-z]{2}$/i';

            case 'ar':
            case 'am':
            case 'au':
            case 'at':
            case 'bd':
            case 'be':
            case 'bg':
            case 'cy':
            case 'dk':
            case 'ge':
            case 'gl':
            case 'hu':
            case 'lv':
            case 'li':
            case 'lu':
            case 'mk':
            case 'md':
            case 'nz':
            case 'no':
            case 'ph':
            case 'si':
            case 'za':
            case 'ch':
            case 'tn':
                return '/^[0-9]{4}$/';

            case 'mv':
            case 'mx':
                return '/^[0-9]{4}[0-9]?$/';

            case 'mn':
                return '/^[0-9]{5}[0-9]?$/';

            case 'pl':
                return '/^[0-9]{2}-[0-9]{3}$/';

            case 'pt':
                return '/^[0-9]{4}(-[0-9]{3})?$/';

            case 'by':
            case 'cn':
            case 'ec':
            case 'in':
            case 'kz':
            case 'kg':
            case 'ro':
            case 'ru':
            case 'sg':
            case 'tj':
            case 'zu':
                return '/^[0-9]{6}$/';

            case 'ca':
                return '/^[a-z][0-9][a-z] [0-9][a-z]([0-9])?$/i';

            case 'az':
                return '/^[0-9]{4}([0-9]{2})?$/';

            case 'sz':
                return '/^[a-z]{1}[0-9]{3}$/i';

            case 'tw':
                return '/^[0-9]{3}([0-9]{2})?$/';

            case 'gb':
                return '/^(([a-z][0-9])|([a-z][0-9]{2})|([a-z][0-9][a-z])|([a-z]{2}[0-9])|([a-z]{2}[0-9]{2})|([a-z]{2}[0-9][a-z])) [0-9][a-z]{2}$/i';
        }

        return null;
    }
}