Baethon\Phln\RegExp

Complexity

Total Complexity

17

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	of()	0	5	2
A	hasDelimiters()	0	14	4
A	wrapInDelimiters()	0	5	2
A	fromString()	0	13	2
A	test()	0	3	1
A	isValidDelimiter()	0	3	1
A	isGlobal()	0	3	1
A	matchAll()	0	12	2
A	__toString()	0	3	1

<?php
declare(strict_types=1);

namespace Baethon\Phln;

use Baethon\Phln\Phln as P;

final class RegExp
{
    /**
     * @var string
     */
    private $pattern;

    /**
     * @var string
     */
    private $modifiers;

    /**
     * @var bool
     */
    private $global = false;

    public function __construct(string $pattern, string $modifiers = '')
    {
        $this->pattern = $this->wrapInDelimiters($pattern);
        $this->modifiers = str_replace('g', '', $modifiers);
        $this->global = (false !== strstr($modifiers, 'g'));
    }

    public function isGlobal(): bool
    {
        return $this->global;
    }

    public function __toString(): string
    {
        return $this->pattern.$this->modifiers;
    }

    private function wrapInDelimiters(string $pattern): string
    {
        return $this->hasDelimiters($pattern) ? $pattern : sprintf(
            '/%s/',
            preg_quote($pattern, '/')
        );
    }

    /**
     * Checks if pattern has valid delimiter
     *
     * @param string $pattern
     * @return bool
     * @see https://secure.php.net/manual/en/regexp.reference.delimiters.php
     */
    private function hasDelimiters(string $pattern): bool
    {
        if (mb_strlen($pattern) < 2) {
            return false;
        }

        $start = substr($pattern, 0, 1);
        $end = substr($pattern, -1);

        if ($start !== $end) {
            return false;
        }

        return static::isValidDelimiter($start) && static::isValidDelimiter($end);
    }

    private static function isValidDelimiter(string $char): bool
    {
        return (bool) preg_match('/^[^a-z0-9\s]$/', $char);
    }

    /**
     * Creates RegExp instance based on passed regular expression.
     *
     * @param string $regexp
     * @return RegExp
     * @example
     *      RegExp::fromString('/foo/gi'); // -> new RegExp('/foo/', 'gi');
     */
    public static function fromString(string $regexp): RegExp
    {
        $start = substr($regexp, 0, 1);

        if (false === static::isValidDelimiter($start)) {
            return new static($regexp);
        }

        $endPosition = strrpos($regexp, $start);
        $pattern = substr($regexp, 0, $endPosition + 1);
        $modifiers = substr($regexp, $endPosition + 1);

        return new static($pattern, $modifiers);
    }

    public static function of($regexp): RegExp
    {
        return ($regexp instanceof static)
            ? $regexp
            : static::fromString($regexp);
    }

    public function matchAll(string $test): array
    {
        $matches = [];
        preg_match_all((string) $this, $test, $matches, PREG_SET_ORDER);

        $slice = function ($list) {
            return count($list) > 1
                ? array_slice($list, 1)
                : $list;
        };

        return P::flatMap($slice, $matches);

The expression return Baethon\Phln\Phln::flatMap($slice, $matches) could return the type callable which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    public function test(string $string): bool
    {
        return (bool) preg_match((string) $this, $string);
    }
}