Class luya\web\CompositionResolver

                public function __construct(Request $request, Composition $composition, array $config = [])
{
    $this->request = $request;
    $this->composition = $composition;
    parent::__construct($config);
}

            

                protected function buildRegexPattern()
{
    return "@^{$this->composition->pattern}\/@";
}

            

                protected function getInternalResolverArray()
{
    if ($this->_resolved === null) {
        $requestPathInfo = $this->trailingPathInfo();
        $newRegex = $this->buildRegexPattern();
        
        // extract the rules from the regex pattern, this means you get array with keys for every rule inside the pattern string
        // example pattern: <langShortCode:[a-z]{2}>-<countryShortCode:[a-z]{2}>
        /* [0]=>
             array(3) {
                 [0]=> string(24) "<langShortCode:[a-z]{2}>"
                 [1]=> string(13) "langShortCode"
                 [2]=> string(8) "[a-z]{2}"
             }
           [1]=>
             array(3) {
                 [0]=> string(27) "<countryShortCode:[a-z]{2}>"
                 [1]=> string(16) "countryShortCode"
                 [2]=> string(8) "[a-z]{2}"
             }
         */
        preg_match_all(static::VAR_MATCH_REGEX, $this->composition->pattern, $patternDefinitions, PREG_SET_ORDER);
        
        foreach ($patternDefinitions as $definition) {
            $newRegex = str_replace($definition[0], '('.rtrim(ltrim($definition[2], '('), ')').')', $newRegex);
        }
        
        preg_match_all($newRegex, $requestPathInfo, $matches, PREG_SET_ORDER);
        
        if (isset($matches[0]) && !empty($matches[0])) {
            $keys = [];
            $matches = $matches[0];
            
            $compositionPrefix = $matches[0];
            unset($matches[0]);
            $matches = array_values($matches);
            
            foreach ($matches as $k => $v) {
                $keys[$patternDefinitions[$k][1]] = $v;
            }
            
            $route = StringHelper::replaceFirst($compositionPrefix, '', $requestPathInfo);
        } else {
            $matches = [];
            $keys = $this->composition->default;
            $route = $requestPathInfo;
        }
        // the validation check for validates composition values is enabled
        if ($this->composition->expectedValues) {
            foreach ($keys as $patternKey => $expectedPatternValue) {
                if (!array_key_exists($patternKey, $this->composition->expectedValues)) {
                    throw new InvalidConfigException("Invalid configuration, the expectedValues configuration key \"{$patternKey}\" does not exists in the resolved values list.");
                }
                $possibleValues = $this->composition->expectedValues[$patternKey];
                if (!in_array($expectedPatternValue, $possibleValues)) {
                    throw new NotFoundHttpException("The requested composition key \"{$patternKey}\" with value \"{$expectedPatternValue}\" is not in the possible values list.");
                }
            }
        }
        
        $this->_resolved = [
            'route' => rtrim($route, '/'),
            'values' => $keys,
        ];
    }
    
    return $this->_resolved;
}

            

                public function getResolvedKeyValue($key)
{
    $keys = $this->resolvedValues;
    
    return isset($keys[$key]) ? $keys[$key] : false;
}

            

                public function getResolvedKeys()
{
    return array_keys($this->getResolvedValues());
}

            

                public function getResolvedPath()
{
    return $this->getInternalResolverArray()['route'];
}

            

                public function getResolvedValues()
{
    return $this->getInternalResolverArray()['values'];
}

            

                protected function trailingPathInfo()
{
    return Url::trailing($this->request->pathInfo);
}