Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:37
📁 Annotation	-	2025-05-25 12:37
📄 CompiledRoute.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; /* * CompiledRoutes are returned by the RouteCompiler class. * * @author Fabien Potencier <fabien@symfony.com> / class CompiledRoute { private $variables; private $tokens; private $staticPrefix; private $regex; private $pathVariables; private $hostVariables; private $hostRegex; private $hostTokens; /* * Constructor. * * @param string $staticPrefix The static prefix of the compiled route * @param string $regex The regular expression to use to match this route * @param array $tokens An array of tokens to use to generate URL for this route * @param array $pathVariables An array of path variables * @param string\|null $hostRegex Host regex * @param array $hostTokens Host tokens * @param array $hostVariables An array of host variables * @param array $variables An array of variables (variables defined in the path and in the host patterns) / public function __construct($staticPrefix, $regex, array $tokens, array $pathVariables, $hostRegex = null, array $hostTokens = array(), array $hostVariables = array(), array $variables = array()) { $this->staticPrefix = (string) $staticPrefix; $this->regex = $regex; $this->tokens = $tokens; $this->pathVariables = $pathVariables; $this->hostRegex = $hostRegex; $this->hostTokens = $hostTokens; $this->hostVariables = $hostVariables; $this->variables = $variables; } /* * Returns the static prefix. * * @return string The static prefix / public function getStaticPrefix() { return $this->staticPrefix; } /* * Returns the regex. * * @return string The regex / public function getRegex() { return $this->regex; } /* * Returns the host regex * * @return string\|null The host regex or null / public function getHostRegex() { return $this->hostRegex; } /* * Returns the tokens. * * @return array The tokens / public function getTokens() { return $this->tokens; } /* * Returns the host tokens. * * @return array The tokens / public function getHostTokens() { return $this->hostTokens; } /* * Returns the variables. * * @return array The variables / public function getVariables() { return $this->variables; } /* * Returns the path variables. * * @return array The variables / public function getPathVariables() { return $this->pathVariables; } /* * Returns the host variables. * * @return array The variables */ public function getHostVariables() { return $this->hostVariables; } }	3.18 KB	2024-07-17 10:22
📁 Exception	-	2025-05-25 12:37
📁 Generator	-	2025-05-25 12:37
📁 Loader	-	2025-05-25 12:37
📁 Matcher	-	2025-05-25 12:37
📄 RequestContext.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; use Symfony\Component\HttpFoundation\Request; /* * Holds information about the current request. * * @author Fabien Potencier <fabien@symfony.com> * * @api / class RequestContext { private $baseUrl; private $pathInfo; private $method; private $host; private $scheme; private $httpPort; private $httpsPort; private $queryString; /* * @var array / private $parameters = array(); /* * Constructor. * * @param string $baseUrl The base URL * @param string $method The HTTP method * @param string $host The HTTP host name * @param string $scheme The HTTP scheme * @param integer $httpPort The HTTP port * @param integer $httpsPort The HTTPS port * @param string $path The path * @param string $queryString The query string * * @api / public function __construct($baseUrl = '', $method = 'GET', $host = 'localhost', $scheme = 'http', $httpPort = 80, $httpsPort = 443, $path = '/', $queryString = '') { $this->baseUrl = $baseUrl; $this->method = strtoupper($method); $this->host = $host; $this->scheme = strtolower($scheme); $this->httpPort = $httpPort; $this->httpsPort = $httpsPort; $this->pathInfo = $path; $this->queryString = $queryString; } public function fromRequest(Request $request) { $this->setBaseUrl($request->getBaseUrl()); $this->setPathInfo($request->getPathInfo()); $this->setMethod($request->getMethod()); $this->setHost($request->getHost()); $this->setScheme($request->getScheme()); $this->setHttpPort($request->isSecure() ? $this->httpPort : $request->getPort()); $this->setHttpsPort($request->isSecure() ? $request->getPort() : $this->httpsPort); $this->setQueryString($request->server->get('QUERY_STRING')); } /* * Gets the base URL. * * @return string The base URL / public function getBaseUrl() { return $this->baseUrl; } /* * Sets the base URL. * * @param string $baseUrl The base URL * * @api / public function setBaseUrl($baseUrl) { $this->baseUrl = $baseUrl; } /* * Gets the path info. * * @return string The path info / public function getPathInfo() { return $this->pathInfo; } /* * Sets the path info. * * @param string $pathInfo The path info / public function setPathInfo($pathInfo) { $this->pathInfo = $pathInfo; } /* * Gets the HTTP method. * * The method is always an uppercased string. * * @return string The HTTP method / public function getMethod() { return $this->method; } /* * Sets the HTTP method. * * @param string $method The HTTP method * * @api / public function setMethod($method) { $this->method = strtoupper($method); } /* * Gets the HTTP host. * * @return string The HTTP host / public function getHost() { return $this->host; } /* * Sets the HTTP host. * * @param string $host The HTTP host * * @api / public function setHost($host) { $this->host = $host; } /* * Gets the HTTP scheme. * * @return string The HTTP scheme / public function getScheme() { return $this->scheme; } /* * Sets the HTTP scheme. * * @param string $scheme The HTTP scheme * * @api / public function setScheme($scheme) { $this->scheme = strtolower($scheme); } /* * Gets the HTTP port. * * @return string The HTTP port / public function getHttpPort() { return $this->httpPort; } /* * Sets the HTTP port. * * @param string $httpPort The HTTP port * * @api / public function setHttpPort($httpPort) { $this->httpPort = $httpPort; } /* * Gets the HTTPS port. * * @return string The HTTPS port / public function getHttpsPort() { return $this->httpsPort; } /* * Sets the HTTPS port. * * @param string $httpsPort The HTTPS port * * @api / public function setHttpsPort($httpsPort) { $this->httpsPort = $httpsPort; } /* * Gets the query string. * * @return string The query string / public function getQueryString() { return $this->queryString; } /* * Sets the query string. * * @param string $queryString The query string * * @api / public function setQueryString($queryString) { $this->queryString = $queryString; } /* * Returns the parameters. * * @return array The parameters / public function getParameters() { return $this->parameters; } /* * Sets the parameters. * * This method implements a fluent interface. * * @param array $parameters The parameters * * @return Route The current Route instance / public function setParameters(array $parameters) { $this->parameters = $parameters; return $this; } /* * Gets a parameter value. * * @param string $name A parameter name * * @return mixed The parameter value / public function getParameter($name) { return isset($this->parameters[$name]) ? $this->parameters[$name] : null; } /* * Checks if a parameter value is set for the given parameter. * * @param string $name A parameter name * * @return Boolean true if the parameter value is set, false otherwise / public function hasParameter($name) { return array_key_exists($name, $this->parameters); } /* * Sets a parameter value. * * @param string $name A parameter name * @param mixed $parameter The parameter value * * @api */ public function setParameter($name, $parameter) { $this->parameters[$name] = $parameter; } }	6.52 KB	2024-07-17 10:22
📄 RequestContextAwareInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; /* * @api / interface RequestContextAwareInterface { /* * Sets the request context. * * @param RequestContext $context The context * * @api / public function setContext(RequestContext $context); /* * Gets the request context. * * @return RequestContext The context * * @api */ public function getContext(); }	669 B	2024-07-17 10:22
📄 Route.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; /* * A Route describes a route and its parameters. * * @author Fabien Potencier <fabien@symfony.com> * @author Tobias Schultze <http://tobion.de> * * @api / class Route implements \Serializable { /* * @var string / private $path = '/'; /* * @var string / private $host = ''; /* * @var array / private $schemes = array(); /* * @var array / private $methods = array(); /* * @var array / private $defaults = array(); /* * @var array / private $requirements = array(); /* * @var array / private $options = array(); /* * @var null\|CompiledRoute / private $compiled; private $condition; /* * Constructor. * * Available options: * * * compiler_class: A class name able to compile this route instance (RouteCompiler by default) * * @param string $path The path pattern to match * @param array $defaults An array of default parameter values * @param array $requirements An array of requirements for parameters (regexes) * @param array $options An array of options * @param string $host The host pattern to match * @param string\|array $schemes A required URI scheme or an array of restricted schemes * @param string\|array $methods A required HTTP method or an array of restricted methods * @param string $condition A condition that should evaluate to true for the route to match * * @api / public function __construct($path, array $defaults = array(), array $requirements = array(), array $options = array(), $host = '', $schemes = array(), $methods = array(), $condition = null) { $this->setPath($path); $this->setDefaults($defaults); $this->setRequirements($requirements); $this->setOptions($options); $this->setHost($host); // The conditions make sure that an initial empty $schemes/$methods does not override the corresponding requirement. // They can be removed when the BC layer is removed. if ($schemes) { $this->setSchemes($schemes); } if ($methods) { $this->setMethods($methods); } $this->setCondition($condition); } public function serialize() { return serialize(array( 'path' => $this->path, 'host' => $this->host, 'defaults' => $this->defaults, 'requirements' => $this->requirements, 'options' => $this->options, 'schemes' => $this->schemes, 'methods' => $this->methods, 'condition' => $this->condition, )); } public function unserialize($data) { $data = unserialize($data); $this->path = $data['path']; $this->host = $data['host']; $this->defaults = $data['defaults']; $this->requirements = $data['requirements']; $this->options = $data['options']; $this->schemes = $data['schemes']; $this->methods = $data['methods']; $this->condition = $data['condition']; } /* * Returns the pattern for the path. * * @return string The pattern * * @deprecated Deprecated in 2.2, to be removed in 3.0. Use getPath instead. / public function getPattern() { return $this->path; } /* * Sets the pattern for the path. * * This method implements a fluent interface. * * @param string $pattern The path pattern * * @return Route The current Route instance * * @deprecated Deprecated in 2.2, to be removed in 3.0. Use setPath instead. / public function setPattern($pattern) { return $this->setPath($pattern); } /* * Returns the pattern for the path. * * @return string The path pattern / public function getPath() { return $this->path; } /* * Sets the pattern for the path. * * This method implements a fluent interface. * * @param string $pattern The path pattern * * @return Route The current Route instance / public function setPath($pattern) { // A pattern must start with a slash and must not have multiple slashes at the beginning because the // generated path for this route would be confused with a network path, e.g. '//domain.com/path'. $this->path = '/'.ltrim(trim($pattern), '/'); $this->compiled = null; return $this; } /* * Returns the pattern for the host. * * @return string The host pattern / public function getHost() { return $this->host; } /* * Sets the pattern for the host. * * This method implements a fluent interface. * * @param string $pattern The host pattern * * @return Route The current Route instance / public function setHost($pattern) { $this->host = (string) $pattern; $this->compiled = null; return $this; } /* * Returns the lowercased schemes this route is restricted to. * So an empty array means that any scheme is allowed. * * @return array The schemes / public function getSchemes() { return $this->schemes; } /* * Sets the schemes (e.g. 'https') this route is restricted to. * So an empty array means that any scheme is allowed. * * This method implements a fluent interface. * * @param string\|array $schemes The scheme or an array of schemes * * @return Route The current Route instance / public function setSchemes($schemes) { $this->schemes = array_map('strtolower', (array) $schemes); // this is to keep BC and will be removed in a future version if ($this->schemes) { $this->requirements['_scheme'] = implode('\|', $this->schemes); } else { unset($this->requirements['_scheme']); } $this->compiled = null; return $this; } /* * Returns the uppercased HTTP methods this route is restricted to. * So an empty array means that any method is allowed. * * @return array The schemes / public function getMethods() { return $this->methods; } /* * Sets the HTTP methods (e.g. 'POST') this route is restricted to. * So an empty array means that any method is allowed. * * This method implements a fluent interface. * * @param string\|array $methods The method or an array of methods * * @return Route The current Route instance / public function setMethods($methods) { $this->methods = array_map('strtoupper', (array) $methods); // this is to keep BC and will be removed in a future version if ($this->methods) { $this->requirements['_method'] = implode('\|', $this->methods); } else { unset($this->requirements['_method']); } $this->compiled = null; return $this; } /* * Returns the options. * * @return array The options / public function getOptions() { return $this->options; } /* * Sets the options. * * This method implements a fluent interface. * * @param array $options The options * * @return Route The current Route instance / public function setOptions(array $options) { $this->options = array( 'compiler_class' => 'Symfony\\Component\\Routing\\RouteCompiler', ); return $this->addOptions($options); } /* * Adds options. * * This method implements a fluent interface. * * @param array $options The options * * @return Route The current Route instance / public function addOptions(array $options) { foreach ($options as $name => $option) { $this->options[$name] = $option; } $this->compiled = null; return $this; } /* * Sets an option value. * * This method implements a fluent interface. * * @param string $name An option name * @param mixed $value The option value * * @return Route The current Route instance * * @api / public function setOption($name, $value) { $this->options[$name] = $value; $this->compiled = null; return $this; } /* * Get an option value. * * @param string $name An option name * * @return mixed The option value or null when not given / public function getOption($name) { return isset($this->options[$name]) ? $this->options[$name] : null; } /* * Checks if an option has been set * * @param string $name An option name * * @return Boolean true if the option is set, false otherwise / public function hasOption($name) { return array_key_exists($name, $this->options); } /* * Returns the defaults. * * @return array The defaults / public function getDefaults() { return $this->defaults; } /* * Sets the defaults. * * This method implements a fluent interface. * * @param array $defaults The defaults * * @return Route The current Route instance / public function setDefaults(array $defaults) { $this->defaults = array(); return $this->addDefaults($defaults); } /* * Adds defaults. * * This method implements a fluent interface. * * @param array $defaults The defaults * * @return Route The current Route instance / public function addDefaults(array $defaults) { foreach ($defaults as $name => $default) { $this->defaults[$name] = $default; } $this->compiled = null; return $this; } /* * Gets a default value. * * @param string $name A variable name * * @return mixed The default value or null when not given / public function getDefault($name) { return isset($this->defaults[$name]) ? $this->defaults[$name] : null; } /* * Checks if a default value is set for the given variable. * * @param string $name A variable name * * @return Boolean true if the default value is set, false otherwise / public function hasDefault($name) { return array_key_exists($name, $this->defaults); } /* * Sets a default value. * * @param string $name A variable name * @param mixed $default The default value * * @return Route The current Route instance * * @api / public function setDefault($name, $default) { $this->defaults[$name] = $default; $this->compiled = null; return $this; } /* * Returns the requirements. * * @return array The requirements / public function getRequirements() { return $this->requirements; } /* * Sets the requirements. * * This method implements a fluent interface. * * @param array $requirements The requirements * * @return Route The current Route instance / public function setRequirements(array $requirements) { $this->requirements = array(); return $this->addRequirements($requirements); } /* * Adds requirements. * * This method implements a fluent interface. * * @param array $requirements The requirements * * @return Route The current Route instance / public function addRequirements(array $requirements) { foreach ($requirements as $key => $regex) { $this->requirements[$key] = $this->sanitizeRequirement($key, $regex); } $this->compiled = null; return $this; } /* * Returns the requirement for the given key. * * @param string $key The key * * @return string\|null The regex or null when not given / public function getRequirement($key) { return isset($this->requirements[$key]) ? $this->requirements[$key] : null; } /* * Checks if a requirement is set for the given key. * * @param string $key A variable name * * @return Boolean true if a requirement is specified, false otherwise / public function hasRequirement($key) { return array_key_exists($key, $this->requirements); } /* * Sets a requirement for the given key. * * @param string $key The key * @param string $regex The regex * * @return Route The current Route instance * * @api / public function setRequirement($key, $regex) { $this->requirements[$key] = $this->sanitizeRequirement($key, $regex); $this->compiled = null; return $this; } /* * Returns the condition. * * @return string The condition / public function getCondition() { return $this->condition; } /* * Sets the condition. * * This method implements a fluent interface. * * @param string $condition The condition * * @return Route The current Route instance / public function setCondition($condition) { $this->condition = (string) $condition; $this->compiled = null; return $this; } /* * Compiles the route. * * @return CompiledRoute A CompiledRoute instance * * @throws \LogicException If the Route cannot be compiled because the * path or host pattern is invalid * * @see RouteCompiler which is responsible for the compilation process */ public function compile() { if (null !== $this->compiled) { return $this->compiled; } $class = $this->getOption('compiler_class'); return $this->compiled = $class::compile($this); } private function sanitizeRequirement($key, $regex) { if (!is_string($regex)) { throw new \InvalidArgumentException(sprintf('Routing requirement for "%s" must be a string.', $key)); } if ('' !== $regex && '^' === $regex[0]) { $regex = (string) substr($regex, 1); // returns false for a single character } if ('$' === substr($regex, -1)) { $regex = substr($regex, 0, -1); } if ('' === $regex) { throw new \InvalidArgumentException(sprintf('Routing requirement for "%s" cannot be empty.', $key)); } // this is to keep BC and will be removed in a future version if ('_scheme' === $key) { $this->setSchemes(explode('\|', $regex)); } elseif ('_method' === $key) { $this->setMethods(explode('\|', $regex)); } return $regex; } }	15.27 KB	2024-07-17 10:22
📄 RouteCollection.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; use Symfony\Component\Config\Resource\ResourceInterface; /* * A RouteCollection represents a set of Route instances. * * When adding a route at the end of the collection, an existing route * with the same name is removed first. So there can only be one route * with a given name. * * @author Fabien Potencier <fabien@symfony.com> * @author Tobias Schultze <http://tobion.de> * * @api / class RouteCollection implements \IteratorAggregate, \Countable { /* * @var Route[] / private $routes = array(); /* * @var array / private $resources = array(); public function __clone() { foreach ($this->routes as $name => $route) { $this->routes[$name] = clone $route; } } /* * Gets the current RouteCollection as an Iterator that includes all routes. * * It implements \IteratorAggregate. * * @see all() * * @return \ArrayIterator An \ArrayIterator object for iterating over routes / public function getIterator() { return new \ArrayIterator($this->routes); } /* * Gets the number of Routes in this collection. * * @return int The number of routes / public function count() { return count($this->routes); } /* * Adds a route. * * @param string $name The route name * @param Route $route A Route instance * * @api / public function add($name, Route $route) { unset($this->routes[$name]); $this->routes[$name] = $route; } /* * Returns all routes in this collection. * * @return Route[] An array of routes / public function all() { return $this->routes; } /* * Gets a route by name. * * @param string $name The route name * * @return Route\|null A Route instance or null when not found / public function get($name) { return isset($this->routes[$name]) ? $this->routes[$name] : null; } /* * Removes a route or an array of routes by name from the collection * * @param string\|array $name The route name or an array of route names / public function remove($name) { foreach ((array) $name as $n) { unset($this->routes[$n]); } } /* * Adds a route collection at the end of the current set by appending all * routes of the added collection. * * @param RouteCollection $collection A RouteCollection instance * * @api / public function addCollection(RouteCollection $collection) { // we need to remove all routes with the same names first because just replacing them // would not place the new route at the end of the merged array foreach ($collection->all() as $name => $route) { unset($this->routes[$name]); $this->routes[$name] = $route; } $this->resources = array_merge($this->resources, $collection->getResources()); } /* * Adds a prefix to the path of all child routes. * * @param string $prefix An optional prefix to add before each pattern of the route collection * @param array $defaults An array of default values * @param array $requirements An array of requirements * * @api / public function addPrefix($prefix, array $defaults = array(), array $requirements = array()) { $prefix = trim(trim($prefix), '/'); if ('' === $prefix) { return; } foreach ($this->routes as $route) { $route->setPath('/'.$prefix.$route->getPath()); $route->addDefaults($defaults); $route->addRequirements($requirements); } } /* * Sets the host pattern on all routes. * * @param string $pattern The pattern * @param array $defaults An array of default values * @param array $requirements An array of requirements / public function setHost($pattern, array $defaults = array(), array $requirements = array()) { foreach ($this->routes as $route) { $route->setHost($pattern); $route->addDefaults($defaults); $route->addRequirements($requirements); } } /* * Sets a condition on all routes. * * Existing conditions will be overridden. * * @param string $condition The condition / public function setCondition($condition) { foreach ($this->routes as $route) { $route->setCondition($condition); } } /* * Adds defaults to all routes. * * An existing default value under the same name in a route will be overridden. * * @param array $defaults An array of default values / public function addDefaults(array $defaults) { if ($defaults) { foreach ($this->routes as $route) { $route->addDefaults($defaults); } } } /* * Adds requirements to all routes. * * An existing requirement under the same name in a route will be overridden. * * @param array $requirements An array of requirements / public function addRequirements(array $requirements) { if ($requirements) { foreach ($this->routes as $route) { $route->addRequirements($requirements); } } } /* * Adds options to all routes. * * An existing option value under the same name in a route will be overridden. * * @param array $options An array of options / public function addOptions(array $options) { if ($options) { foreach ($this->routes as $route) { $route->addOptions($options); } } } /* * Sets the schemes (e.g. 'https') all child routes are restricted to. * * @param string\|array $schemes The scheme or an array of schemes / public function setSchemes($schemes) { foreach ($this->routes as $route) { $route->setSchemes($schemes); } } /* * Sets the HTTP methods (e.g. 'POST') all child routes are restricted to. * * @param string\|array $methods The method or an array of methods / public function setMethods($methods) { foreach ($this->routes as $route) { $route->setMethods($methods); } } /* * Returns an array of resources loaded to build this collection. * * @return ResourceInterface[] An array of resources / public function getResources() { return array_unique($this->resources); } /* * Adds a resource for this collection. * * @param ResourceInterface $resource A resource instance */ public function addResource(ResourceInterface $resource) { $this->resources[] = $resource; } }	7.17 KB	2024-07-17 10:22
📄 RouteCompiler.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; /* * RouteCompiler compiles Route instances to CompiledRoute instances. * * @author Fabien Potencier <fabien@symfony.com> * @author Tobias Schultze <http://tobion.de> / class RouteCompiler implements RouteCompilerInterface { const REGEX_DELIMITER = '#'; /* * This string defines the characters that are automatically considered separators in front of * optional placeholders (with default and no static text following). Such a single separator * can be left out together with the optional placeholder from matching and generating URLs. / const SEPARATORS = '/,;.:-_~+=@\|'; /** * {@inheritDoc} * * @throws \LogicException If a variable is referenced more than once * @throws \DomainException If a variable name is numeric because PHP raises an error for such * subpatterns in PCRE and thus would break matching, e.g. "(?P<123>.+)". / public static function compile(Route $route) { $staticPrefix = null; $hostVariables = array(); $pathVariables = array(); $variables = array(); $tokens = array(); $regex = null; $hostRegex = null; $hostTokens = array(); if ('' !== $host = $route->getHost()) { $result = self::compilePattern($route, $host, true); $hostVariables = $result['variables']; $variables = array_merge($variables, $hostVariables); $hostTokens = $result['tokens']; $hostRegex = $result['regex']; } $path = $route->getPath(); $result = self::compilePattern($route, $path, false); $staticPrefix = $result['staticPrefix']; $pathVariables = $result['variables']; $variables = array_merge($variables, $pathVariables); $tokens = $result['tokens']; $regex = $result['regex']; return new CompiledRoute( $staticPrefix, $regex, $tokens, $pathVariables, $hostRegex, $hostTokens, $hostVariables, array_unique($variables) ); } private static function compilePattern(Route $route, $pattern, $isHost) { $tokens = array(); $variables = array(); $matches = array(); $pos = 0; $defaultSeparator = $isHost ? '.' : '/'; // Match all variables enclosed in "{}" and iterate over them. But we only want to match the innermost variable // in case of nested "{}", e.g. {foo{bar}}. This in ensured because \w does not match "{" or "}" itself. preg_match_all('#\{\w+\}#', $pattern, $matches, PREG_OFFSET_CAPTURE \| PREG_SET_ORDER); foreach ($matches as $match) { $varName = substr($match[0][0], 1, -1); // get all static text preceding the current variable $precedingText = substr($pattern, $pos, $match[0][1] - $pos); $pos = $match[0][1] + strlen($match[0][0]); $precedingChar = strlen($precedingText) > 0 ? substr($precedingText, -1) : ''; $isSeparator = '' !== $precedingChar && false !== strpos(static::SEPARATORS, $precedingChar); if (is_numeric($varName)) { throw new \DomainException(sprintf('Variable name "%s" cannot be numeric in route pattern "%s". Please use a different name.', $varName, $pattern)); } if (in_array($varName, $variables)) { throw new \LogicException(sprintf('Route pattern "%s" cannot reference variable name "%s" more than once.', $pattern, $varName)); } if ($isSeparator && strlen($precedingText) > 1) { $tokens[] = array('text', substr($precedingText, 0, -1)); } elseif (!$isSeparator && strlen($precedingText) > 0) { $tokens[] = array('text', $precedingText); } $regexp = $route->getRequirement($varName); if (null === $regexp) { $followingPattern = (string) substr($pattern, $pos); // Find the next static character after the variable that functions as a separator. By default, this separator and '/' // are disallowed for the variable. This default requirement makes sure that optional variables can be matched at all // and that the generating-matching-combination of URLs unambiguous, i.e. the params used for generating the URL are // the same that will be matched. Example: new Route('/{page}.{_format}', array('_format' => 'html')) // If {page} would also match the separating dot, {_format} would never match as {page} will eagerly consume everything. // Also even if {_format} was not optional the requirement prevents that {page} matches something that was originally // part of {_format} when generating the URL, e.g. _format = 'mobile.html'. $nextSeparator = self::findNextSeparator($followingPattern); $regexp = sprintf( '[^%s%s]+', preg_quote($defaultSeparator, self::REGEX_DELIMITER), $defaultSeparator !== $nextSeparator && '' !== $nextSeparator ? preg_quote($nextSeparator, self::REGEX_DELIMITER) : '' ); if (('' !== $nextSeparator && !preg_match('#^\{\w+\}#', $followingPattern)) \|\| '' === $followingPattern) { // When we have a separator, which is disallowed for the variable, we can optimize the regex with a possessive // quantifier. This prevents useless backtracking of PCRE and improves performance by 20% for matching those patterns. // Given the above example, there is no point in backtracking into {page} (that forbids the dot) when a dot must follow // after it. This optimization cannot be applied when the next char is no real separator or when the next variable is // directly adjacent, e.g. '/{x}{y}'. $regexp .= '+'; } } $tokens[] = array('variable', $isSeparator ? $precedingChar : '', $regexp, $varName); $variables[] = $varName; } if ($pos < strlen($pattern)) { $tokens[] = array('text', substr($pattern, $pos)); } // find the first optional token $firstOptional = PHP_INT_MAX; if (!$isHost) { for ($i = count($tokens) - 1; $i >= 0; $i--) { $token = $tokens[$i]; if ('variable' === $token[0] && $route->hasDefault($token[3])) { $firstOptional = $i; } else { break; } } } // compute the matching regexp $regexp = ''; for ($i = 0, $nbToken = count($tokens); $i < $nbToken; $i++) { $regexp .= self::computeRegexp($tokens, $i, $firstOptional); } return array( 'staticPrefix' => 'text' === $tokens[0][0] ? $tokens[0][1] : '', 'regex' => self::REGEX_DELIMITER.'^'.$regexp.'$'.self::REGEX_DELIMITER.'s', 'tokens' => array_reverse($tokens), 'variables' => $variables, ); } /* * Returns the next static character in the Route pattern that will serve as a separator. * * @param string $pattern The route pattern * * @return string The next static character that functions as separator (or empty string when none available) / private static function findNextSeparator($pattern) { if ('' == $pattern) { // return empty string if pattern is empty or false (false which can be returned by substr) return ''; } // first remove all placeholders from the pattern so we can find the next real static character $pattern = preg_replace('#\{\w+\}#', '', $pattern); return isset($pattern[0]) && false !== strpos(static::SEPARATORS, $pattern[0]) ? $pattern[0] : ''; } /* * Computes the regexp used to match a specific token. It can be static text or a subpattern. * * @param array $tokens The route tokens * @param integer $index The index of the current token * @param integer $firstOptional The index of the first optional token * * @return string The regexp pattern for a single token */ private static function computeRegexp(array $tokens, $index, $firstOptional) { $token = $tokens[$index]; if ('text' === $token[0]) { // Text tokens return preg_quote($token[1], self::REGEX_DELIMITER); } else { // Variable tokens if (0 === $index && 0 === $firstOptional) { // When the only token is an optional variable token, the separator is required return sprintf('%s(?P<%s>%s)?', preg_quote($token[1], self::REGEX_DELIMITER), $token[3], $token[2]); } else { $regexp = sprintf('%s(?P<%s>%s)', preg_quote($token[1], self::REGEX_DELIMITER), $token[3], $token[2]); if ($index >= $firstOptional) { // Enclose each optional token in a subpattern to make it optional. // "?:" means it is non-capturing, i.e. the portion of the subject string that // matched the optional subpattern is not passed back. $regexp = "(?:$regexp"; $nbTokens = count($tokens); if ($nbTokens - 1 == $index) { // Close the optional subpatterns $regexp .= str_repeat(")?", $nbTokens - $firstOptional - (0 === $firstOptional ? 1 : 0)); } } return $regexp; } } } }	9.97 KB	2024-07-17 10:22
📄 RouteCompilerInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; /* * RouteCompilerInterface is the interface that all RouteCompiler classes must implement. * * @author Fabien Potencier <fabien@symfony.com> / interface RouteCompilerInterface { /* * Compiles the current route instance. * * @param Route $route A Route instance * * @return CompiledRoute A CompiledRoute instance * * @throws \LogicException If the Route cannot be compiled because the * path or host pattern is invalid */ public static function compile(Route $route); }	830 B	2024-07-17 10:22
📄 Router.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; use Symfony\Component\Config\Loader\LoaderInterface; use Symfony\Component\Config\ConfigCache; use Psr\Log\LoggerInterface; use Symfony\Component\Routing\Generator\ConfigurableRequirementsInterface; use Symfony\Component\Routing\Generator\UrlGeneratorInterface; use Symfony\Component\Routing\Generator\Dumper\GeneratorDumperInterface; use Symfony\Component\Routing\Matcher\RequestMatcherInterface; use Symfony\Component\Routing\Matcher\UrlMatcherInterface; use Symfony\Component\Routing\Matcher\Dumper\MatcherDumperInterface; use Symfony\Component\HttpFoundation\Request; /* * The Router class is an example of the integration of all pieces of the * routing system for easier use. * * @author Fabien Potencier <fabien@symfony.com> / class Router implements RouterInterface, RequestMatcherInterface { /* * @var UrlMatcherInterface\|null / protected $matcher; /* * @var UrlGeneratorInterface\|null / protected $generator; /* * @var RequestContext / protected $context; /* * @var LoaderInterface / protected $loader; /* * @var RouteCollection\|null / protected $collection; /* * @var mixed / protected $resource; /* * @var array / protected $options = array(); /* * @var LoggerInterface\|null / protected $logger; /* * Constructor. * * @param LoaderInterface $loader A LoaderInterface instance * @param mixed $resource The main resource to load * @param array $options An array of options * @param RequestContext $context The context * @param LoggerInterface $logger A logger instance / public function __construct(LoaderInterface $loader, $resource, array $options = array(), RequestContext $context = null, LoggerInterface $logger = null) { $this->loader = $loader; $this->resource = $resource; $this->logger = $logger; $this->context = $context ?: new RequestContext(); $this->setOptions($options); } /* * Sets options. * * Available options: * * * cache_dir: The cache directory (or null to disable caching) * * debug: Whether to enable debugging or not (false by default) * * resource_type: Type hint for the main resource (optional) * * @param array $options An array of options * * @throws \InvalidArgumentException When unsupported option is provided / public function setOptions(array $options) { $this->options = array( 'cache_dir' => null, 'debug' => false, 'generator_class' => 'Symfony\\Component\\Routing\\Generator\\UrlGenerator', 'generator_base_class' => 'Symfony\\Component\\Routing\\Generator\\UrlGenerator', 'generator_dumper_class' => 'Symfony\\Component\\Routing\\Generator\\Dumper\\PhpGeneratorDumper', 'generator_cache_class' => 'ProjectUrlGenerator', 'matcher_class' => 'Symfony\\Component\\Routing\\Matcher\\UrlMatcher', 'matcher_base_class' => 'Symfony\\Component\\Routing\\Matcher\\UrlMatcher', 'matcher_dumper_class' => 'Symfony\\Component\\Routing\\Matcher\\Dumper\\PhpMatcherDumper', 'matcher_cache_class' => 'ProjectUrlMatcher', 'resource_type' => null, 'strict_requirements' => true, ); // check option names and live merge, if errors are encountered Exception will be thrown $invalid = array(); foreach ($options as $key => $value) { if (array_key_exists($key, $this->options)) { $this->options[$key] = $value; } else { $invalid[] = $key; } } if ($invalid) { throw new \InvalidArgumentException(sprintf('The Router does not support the following options: "%s".', implode('", "', $invalid))); } } /* * Sets an option. * * @param string $key The key * @param mixed $value The value * * @throws \InvalidArgumentException / public function setOption($key, $value) { if (!array_key_exists($key, $this->options)) { throw new \InvalidArgumentException(sprintf('The Router does not support the "%s" option.', $key)); } $this->options[$key] = $value; } /* * Gets an option value. * * @param string $key The key * * @return mixed The value * * @throws \InvalidArgumentException / public function getOption($key) { if (!array_key_exists($key, $this->options)) { throw new \InvalidArgumentException(sprintf('The Router does not support the "%s" option.', $key)); } return $this->options[$key]; } /* * {@inheritdoc} / public function getRouteCollection() { if (null === $this->collection) { $this->collection = $this->loader->load($this->resource, $this->options['resource_type']); } return $this->collection; } /* * {@inheritdoc} / public function setContext(RequestContext $context) { $this->context = $context; if (null !== $this->matcher) { $this->getMatcher()->setContext($context); } if (null !== $this->generator) { $this->getGenerator()->setContext($context); } } /* * {@inheritdoc} / public function getContext() { return $this->context; } /* * {@inheritdoc} / public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH) { return $this->getGenerator()->generate($name, $parameters, $referenceType); } /* * {@inheritdoc} / public function match($pathinfo) { return $this->getMatcher()->match($pathinfo); } /* * {@inheritdoc} / public function matchRequest(Request $request) { $matcher = $this->getMatcher(); if (!$matcher instanceof RequestMatcherInterface) { // fallback to the default UrlMatcherInterface return $matcher->match($request->getPathInfo()); } return $matcher->matchRequest($request); } /* * Gets the UrlMatcher instance associated with this Router. * * @return UrlMatcherInterface A UrlMatcherInterface instance / public function getMatcher() { if (null !== $this->matcher) { return $this->matcher; } if (null === $this->options['cache_dir'] \|\| null === $this->options['matcher_cache_class']) { return $this->matcher = new $this->options['matcher_class']($this->getRouteCollection(), $this->context); } $class = $this->options['matcher_cache_class']; $cache = new ConfigCache($this->options['cache_dir'].'/'.$class.'.php', $this->options['debug']); if (!$cache->isFresh()) { $dumper = $this->getMatcherDumperInstance(); $options = array( 'class' => $class, 'base_class' => $this->options['matcher_base_class'], ); $cache->write($dumper->dump($options), $this->getRouteCollection()->getResources()); } require_once $cache; return $this->matcher = new $class($this->context); } /* * Gets the UrlGenerator instance associated with this Router. * * @return UrlGeneratorInterface A UrlGeneratorInterface instance / public function getGenerator() { if (null !== $this->generator) { return $this->generator; } if (null === $this->options['cache_dir'] \|\| null === $this->options['generator_cache_class']) { $this->generator = new $this->options['generator_class']($this->getRouteCollection(), $this->context, $this->logger); } else { $class = $this->options['generator_cache_class']; $cache = new ConfigCache($this->options['cache_dir'].'/'.$class.'.php', $this->options['debug']); if (!$cache->isFresh()) { $dumper = $this->getGeneratorDumperInstance(); $options = array( 'class' => $class, 'base_class' => $this->options['generator_base_class'], ); $cache->write($dumper->dump($options), $this->getRouteCollection()->getResources()); } require_once $cache; $this->generator = new $class($this->context, $this->logger); } if ($this->generator instanceof ConfigurableRequirementsInterface) { $this->generator->setStrictRequirements($this->options['strict_requirements']); } return $this->generator; } /* * @return GeneratorDumperInterface / protected function getGeneratorDumperInstance() { return new $this->options['generator_dumper_class']($this->getRouteCollection()); } /* * @return MatcherDumperInterface */ protected function getMatcherDumperInstance() { return new $this->options['matcher_dumper_class']($this->getRouteCollection()); } }	9.5 KB	2024-07-17 10:22
📄 RouterInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Routing; use Symfony\Component\Routing\Generator\UrlGeneratorInterface; use Symfony\Component\Routing\Matcher\UrlMatcherInterface; /* * RouterInterface is the interface that all Router classes must implement. * * This interface is the concatenation of UrlMatcherInterface and UrlGeneratorInterface. * * @author Fabien Potencier <fabien@symfony.com> / interface RouterInterface extends UrlMatcherInterface, UrlGeneratorInterface { /* * Gets the RouteCollection instance associated with this Router. * * @return RouteCollection A RouteCollection instance */ public function getRouteCollection(); }	901 B	2024-07-17 10:22
📄 autoloader.php <?php spl_autoload_register(function ($class) { if ('\\' == $class[0]) { $class = substr($class, 1); } if ( 0 === strpos($class, 'Symfony\\Component\\Routing\\') && file_exists($file = __DIR__.'/../../../'.str_replace('\\', '/', $class).'.php') ) { require_once $file; } });	337 B	2024-07-17 10:22

Terminal