You are here

class RequestMatcher in Zircon Profile 8

Same name in this branch
  1. 8 vendor/symfony/http-foundation/RequestMatcher.php \Symfony\Component\HttpFoundation\RequestMatcher
  2. 8 vendor/symfony-cmf/routing/Tests/Routing/ChainRouterTest.php \Symfony\Cmf\Component\Routing\Tests\Routing\RequestMatcher
Same name and namespace in other branches
  1. 8.0 vendor/symfony/http-foundation/RequestMatcher.php \Symfony\Component\HttpFoundation\RequestMatcher

RequestMatcher compares a pre-defined set of checks against a Request instance.

@author Fabien Potencier <fabien@symfony.com>

Hierarchy

Expanded class hierarchy of RequestMatcher

1 file declares its use of RequestMatcher
RequestMatcherTest.php in vendor/symfony/http-foundation/Tests/RequestMatcherTest.php

File

vendor/symfony/http-foundation/RequestMatcher.php, line 19

Namespace

Symfony\Component\HttpFoundation
View source
class RequestMatcher implements RequestMatcherInterface {

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

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

  /**
   * @var array
   */
  private $methods = array();

  /**
   * @var string
   */
  private $ips = array();

  /**
   * @var array
   */
  private $attributes = array();

  /**
   * @var string[]
   */
  private $schemes = array();

  /**
   * @param string|null          $path
   * @param string|null          $host
   * @param string|string[]|null $methods
   * @param string|string[]|null $ips
   * @param array                $attributes
   * @param string|string[]|null $schemes
   */
  public function __construct($path = null, $host = null, $methods = null, $ips = null, array $attributes = array(), $schemes = null) {
    $this
      ->matchPath($path);
    $this
      ->matchHost($host);
    $this
      ->matchMethod($methods);
    $this
      ->matchIps($ips);
    $this
      ->matchScheme($schemes);
    foreach ($attributes as $k => $v) {
      $this
        ->matchAttribute($k, $v);
    }
  }

  /**
   * Adds a check for the HTTP scheme.
   *
   * @param string|string[]|null $scheme An HTTP scheme or an array of HTTP schemes
   */
  public function matchScheme($scheme) {
    $this->schemes = array_map('strtolower', (array) $scheme);
  }

  /**
   * Adds a check for the URL host name.
   *
   * @param string $regexp A Regexp
   */
  public function matchHost($regexp) {
    $this->host = $regexp;
  }

  /**
   * Adds a check for the URL path info.
   *
   * @param string $regexp A Regexp
   */
  public function matchPath($regexp) {
    $this->path = $regexp;
  }

  /**
   * Adds a check for the client IP.
   *
   * @param string $ip A specific IP address or a range specified using IP/netmask like 192.168.1.0/24
   */
  public function matchIp($ip) {
    $this
      ->matchIps($ip);
  }

  /**
   * Adds a check for the client IP.
   *
   * @param string|string[] $ips A specific IP address or a range specified using IP/netmask like 192.168.1.0/24
   */
  public function matchIps($ips) {
    $this->ips = (array) $ips;
  }

  /**
   * Adds a check for the HTTP method.
   *
   * @param string|string[] $method An HTTP method or an array of HTTP methods
   */
  public function matchMethod($method) {
    $this->methods = array_map('strtoupper', (array) $method);
  }

  /**
   * Adds a check for request attribute.
   *
   * @param string $key    The request attribute name
   * @param string $regexp A Regexp
   */
  public function matchAttribute($key, $regexp) {
    $this->attributes[$key] = $regexp;
  }

  /**
   * {@inheritdoc}
   */
  public function matches(Request $request) {
    if ($this->schemes && !in_array($request
      ->getScheme(), $this->schemes)) {
      return false;
    }
    if ($this->methods && !in_array($request
      ->getMethod(), $this->methods)) {
      return false;
    }
    foreach ($this->attributes as $key => $pattern) {
      if (!preg_match('{' . $pattern . '}', $request->attributes
        ->get($key))) {
        return false;
      }
    }
    if (null !== $this->path && !preg_match('{' . $this->path . '}', rawurldecode($request
      ->getPathInfo()))) {
      return false;
    }
    if (null !== $this->host && !preg_match('{' . $this->host . '}i', $request
      ->getHost())) {
      return false;
    }
    if (IpUtils::checkIp($request
      ->getClientIp(), $this->ips)) {
      return true;
    }

    // Note to future implementors: add additional checks above the
    // foreach above or else your check might not be run!
    return count($this->ips) === 0;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
RequestMatcher::$attributes private property
RequestMatcher::$host private property
RequestMatcher::$ips private property
RequestMatcher::$methods private property
RequestMatcher::$path private property
RequestMatcher::$schemes private property
RequestMatcher::matchAttribute public function Adds a check for request attribute.
RequestMatcher::matches public function Decides whether the rule(s) implemented by the strategy matches the supplied request. Overrides RequestMatcherInterface::matches 1
RequestMatcher::matchHost public function Adds a check for the URL host name.
RequestMatcher::matchIp public function Adds a check for the client IP.
RequestMatcher::matchIps public function Adds a check for the client IP.
RequestMatcher::matchMethod public function Adds a check for the HTTP method.
RequestMatcher::matchPath public function Adds a check for the URL path info.
RequestMatcher::matchScheme public function Adds a check for the HTTP scheme.
RequestMatcher::__construct public function