Swaggest\JsonSchema\Constraint\Format

Complexity

Total Complexity

38

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Test Coverage

Coverage

98.25%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	jsonPointerError()	0	9	5
D	validationError()	0	39	25
B	regexError()	0	18	6
A	dateTimeError()	0	5	2

<?php

namespace Swaggest\JsonSchema\Constraint;

use Swaggest\JsonSchema\Constraint\Format\IdnHostname;
use Swaggest\JsonSchema\Constraint\Format\Iri;
use Swaggest\JsonSchema\Constraint\Format\Uri;

class Format
{
    const DATE_TIME = 'date-time';
    const DATE = 'date';
    const TIME = 'time';
    const URI = 'uri';
    const IRI = 'iri';
    const EMAIL = 'email';
    const IDN_EMAIL = 'idn-email';
    const IPV4 = 'ipv4';
    const IPV6 = 'ipv6';
    const HOSTNAME = 'hostname';
    const IDN_HOSTNAME = 'idn-hostname';
    const REGEX = 'regex';
    const JSON_POINTER = 'json-pointer';
    const RELATIVE_JSON_POINTER = 'relative-json-pointer';
    const URI_REFERENCE = 'uri-reference';
    const IRI_REFERENCE = 'iri-reference';
    const URI_TEMPLATE = 'uri-template';

    private static $dateRegexPart = '(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])';
    private static $timeRegexPart = '([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))?';
    private static $jsonPointerRegex = '_^(?:/|(?:/[^/#]*)*)$_';
    private static $jsonPointerRelativeRegex = '~^(0|[1-9][0-9]*)((?:/[^/#]*)*)(#?)$~';
    private static $jsonPointerUnescapedTilde = '/~([^01]|$)/';

    public static function validationError($format, $data)
    {
        switch ($format) {
            case self::DATE_TIME:
                return self::dateTimeError($data);
            case self::DATE:
                return preg_match('/^' . self::$dateRegexPart . '$/i', $data) ? null : 'Invalid date';
            case self::TIME:
                return preg_match('/^' . self::$timeRegexPart . '$/i', $data) ? null : 'Invalid time';
            case self::URI:
                return Uri::validationError($data, Uri::IS_SCHEME_REQUIRED);
            case self::IRI:
                return Iri::validationError($data);
            case self::EMAIL:
                return filter_var($data, FILTER_VALIDATE_EMAIL) ? null : 'Invalid email';
            case self::IDN_EMAIL:
                return count(explode('@', $data, 3)) === 2 ? null : 'Invalid email';
            case self::IPV4:
                return filter_var($data, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) ? null : 'Invalid ipv4';
            case self::IPV6:
                return filter_var($data, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) ? null : 'Invalid ipv6';
            case self::HOSTNAME:
                return preg_match(Uri::HOSTNAME_REGEX, $data) ? null : 'Invalid hostname';
            case self::IDN_HOSTNAME:
                return IdnHostname::validationError($data);
            case self::REGEX:
                return self::regexError($data);
            case self::JSON_POINTER:
                return self::jsonPointerError($data);
            case self::RELATIVE_JSON_POINTER:
                return self::jsonPointerError($data, true);
            case self::URI_REFERENCE:
                return Uri::validationError($data, Uri::IS_URI_REFERENCE);
            case self::IRI_REFERENCE:
                return Iri::validationError($data, Uri::IS_URI_REFERENCE);
            case self::URI_TEMPLATE:
                return Uri::validationError($data, Uri::IS_URI_TEMPLATE);
        }
        return null;
    }

    public static function dateTimeError($data)
    {
        return preg_match('/^' . self::$dateRegexPart . 'T' . self::$timeRegexPart . '$/i', $data)
            ? null
            : 'Invalid date-time: ' . $data;
    }

    public static function regexError($data)
    {
        if (substr($data, -2) === '\Z') {
            return 'Invalid regex: \Z is not supported';
        }
        if (substr($data, 0, 2) === '\A') {
            return 'Invalid regex: \A is not supported';
        }


        $d = null;
        foreach (array('/', '_', '~', '#', '!', '%', '`', '=') as $delimiter) {
            if (strpos($data, $delimiter) === false) {
                $d = $delimiter;
                break;
            }
        }
        return @preg_match($d . $data . $d, '') === false ? 'Invalid regex: ' . $data : null;

The condition @preg_match($d . $data . $d, '') === false can never be true.

    }

    public static function jsonPointerError($data, $isRelative = false)
    {
        if (preg_match(self::$jsonPointerUnescapedTilde, $data)) {
            return 'Invalid json-pointer: unescaped ~';
        }
        if ($isRelative) {
            return preg_match(self::$jsonPointerRelativeRegex, $data) ? null : 'Invalid relative json-pointer';
        } else {
            return preg_match(self::$jsonPointerRegex, $data) ? null : 'Invalid json-pointer';
        }
    }
}