AlgoWeb\xsdTypes\Facets\PatternTrait

Complexity

Total Complexity

14

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	3
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	checkRegexValidPattern()	0	4	1
A	checkPattern()	0	11	4
A	matchesRegexPattern()	0	5	2
A	setPatternFacet()	0	14	4
B	ProcessRegex()	0	26	3

<?php
namespace AlgoWeb\xsdTypes\Facets;

trait PatternTrait
{
    use XMLPatterns;
    /**
     * @Exclude
     * @var array defines the exact sequence of characters that are acceptable
     */
    private $pattern = array();

    /**
     * @param string $regexPatternToAdd
     * @param mixed  $ProcessMultiCharacterEscape
     */
    protected function setPatternFacet($regexPatternToAdd, $ProcessMultiCharacterEscape = true)

The parameter $ProcessMultiCharacterEscape is not named in camelCase.

    {
        if (null == self::$Letter) {
            self::init();
        }
        $regexPatternToAdd = $this->ProcessRegex($regexPatternToAdd, $ProcessMultiCharacterEscape);

Consider using a different name than the parameter $regexPatternToAdd. This often makes code more readable.

        if (!$this->checkRegexValidPattern($regexPatternToAdd)) {
            $regexPatternToAdd = '/' . $regexPatternToAdd . '/';
            if (!$this->checkRegexValidPattern($regexPatternToAdd)) {
                throw new \InvalidArgumentException('Invalid regex pattern provided: ' . get_class($this));
            }
        }
        $this->pattern[] = $regexPatternToAdd;
    }

    private function ProcessRegex($regexPattern, $ProcessMultiCharacterEscape)

The return type could not be reliably inferred; please add a @return annotation.

The parameter $ProcessMultiCharacterEscape is not named in camelCase.

This method is not in camel caps format.

    {
        if (!$ProcessMultiCharacterEscape) {
            return $regexPattern;
        }
        if (null == self::$NameChar) {
            init();
        }
        
        $regexPattern = str_replace('\S', '[^\s]', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        /**
         * \x{20} matches the character   with index 2016 (3210 or 408) literally (case sensitive)
         * \t matches a tab character (ASCII 9)
         * \n matches a line-feed (newline) character (ASCII 10)
         * \r matches a carriage return (ASCII 13).
         */
        $regexPattern = str_replace('\s', '[\x{20}\t\n\r]', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        $regexPattern = str_replace('\I', '[^\i]', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        $regexPattern = str_replace('\i', self::$Letter.'|_|:', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        $regexPattern = str_replace('\c', self::$NameChar, $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        $regexPattern = str_replace('\D', '[^\d]', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        $regexPattern = str_replace('\d', '\p{Nd}', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        $regexPattern = str_replace('\W', '[^\w]', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        $regexPattern = str_replace('\w', '[\x{0000}-\x{10FFFF}]-[\p{P}\p{Z}\p{C}] ', $regexPattern);

Consider using a different name than the parameter $regexPattern. This often makes code more readable.

        return $regexPattern;
    }

    /**
     * @param string $pattern
     */
    private function checkRegexValidPattern($pattern)
    {
        return !(false === @preg_match($pattern, null));
    }

    /**
     * @param string $v
     */
    private function checkPattern($v)
    {
        if (!empty($this->pattern)) {
            foreach ($this->pattern as $pattern) {
                if (!$this->matchesRegexPattern($pattern, $v)) {
                    throw new \InvalidArgumentException('Assigned value for ' . get_class($this) .
                        ' does not match pattern ' . $pattern);
                }
            }
        }
    }

    /**
     * Checks a pattern against a string.
     *
     * @param  string $pattern the regex pattern
     * @param  string $string  the string to check
     * @return bool   true if string matches pattern
     */
    private function matchesRegexPattern($pattern, $string)
    {
        $matches = null;
        return (1 == preg_match($pattern, $string, $matches) && $string == $matches[0]);
    }
}