class InlineFragmentRenderer in Zircon Profile 8.0

Implements the inline rendering strategy where the Request is rendered by the current HTTP kernel.

@author Fabien Potencier <[e-mail]>

Hierarchy

• class \Symfony\Component\HttpKernel\Fragment\RoutableFragmentRenderer implements FragmentRendererInterface
  • class \Symfony\Component\HttpKernel\Fragment\InlineFragmentRenderer

1 file declares its use of InlineFragmentRenderer

InlineFragmentRendererTest.php in vendor/symfony/http-kernel/Tests/Fragment/InlineFragmentRendererTest.php

File

vendor/symfony/http-kernel/Fragment/InlineFragmentRenderer.php, line 27

Namespace

Symfony\Component\HttpKernel\Fragment

class InlineFragmentRenderer extends RoutableFragmentRenderer {
  private $kernel;
  private $dispatcher;

  /**
   * Constructor.
   *
   * @param HttpKernelInterface      $kernel     A HttpKernelInterface instance
   * @param EventDispatcherInterface $dispatcher A EventDispatcherInterface instance
   */
  public function __construct(HttpKernelInterface $kernel, EventDispatcherInterface $dispatcher = null) {
    $this->kernel = $kernel;
    $this->dispatcher = $dispatcher;
  }

  /**
   * {@inheritdoc}
   *
   * Additional available options:
   *
   *  * alt: an alternative URI to render in case of an error
   */
  public function render($uri, Request $request, array $options = array()) {
    $reference = null;
    if ($uri instanceof ControllerReference) {
      $reference = $uri;

      // Remove attributes from the generated URI because if not, the Symfony
      // routing system will use them to populate the Request attributes. We don't
      // want that as we want to preserve objects (so we manually set Request attributes
      // below instead)
      $attributes = $reference->attributes;
      $reference->attributes = array();

      // The request format and locale might have been overridden by the user
      foreach (array(
        '_format',
        '_locale',
      ) as $key) {
        if (isset($attributes[$key])) {
          $reference->attributes[$key] = $attributes[$key];
        }
      }
      $uri = $this
        ->generateFragmentUri($uri, $request, false, false);
      $reference->attributes = array_merge($attributes, $reference->attributes);
    }
    $subRequest = $this
      ->createSubRequest($uri, $request);

    // override Request attributes as they can be objects (which are not supported by the generated URI)
    if (null !== $reference) {
      $subRequest->attributes
        ->add($reference->attributes);
    }
    $level = ob_get_level();
    try {
      return $this->kernel
        ->handle($subRequest, HttpKernelInterface::SUB_REQUEST, false);
    } catch (\Exception $e) {

      // we dispatch the exception event to trigger the logging
      // the response that comes back is simply ignored
      if (isset($options['ignore_errors']) && $options['ignore_errors'] && $this->dispatcher) {
        $event = new GetResponseForExceptionEvent($this->kernel, $request, HttpKernelInterface::SUB_REQUEST, $e);
        $this->dispatcher
          ->dispatch(KernelEvents::EXCEPTION, $event);
      }

      // let's clean up the output buffers that were created by the sub-request
      Response::closeOutputBuffers($level, false);
      if (isset($options['alt'])) {
        $alt = $options['alt'];
        unset($options['alt']);
        return $this
          ->render($alt, $request, $options);
      }
      if (!isset($options['ignore_errors']) || !$options['ignore_errors']) {
        throw $e;
      }
      return new Response();
    }
  }
  protected function createSubRequest($uri, Request $request) {
    $cookies = $request->cookies
      ->all();
    $server = $request->server
      ->all();

    // Override the arguments to emulate a sub-request.
    // Sub-request object will point to localhost as client ip and real client ip
    // will be included into trusted header for client ip
    try {
      if ($trustedHeaderName = Request::getTrustedHeaderName(Request::HEADER_CLIENT_IP)) {
        $currentXForwardedFor = $request->headers
          ->get($trustedHeaderName, '');
        $server['HTTP_' . $trustedHeaderName] = ($currentXForwardedFor ? $currentXForwardedFor . ', ' : '') . $request
          ->getClientIp();
      }
    } catch (\InvalidArgumentException $e) {

      // Do nothing
    }
    $server['REMOTE_ADDR'] = '127.0.0.1';
    $subRequest = Request::create($uri, 'get', array(), $cookies, array(), $server);
    if ($request->headers
      ->has('Surrogate-Capability')) {
      $subRequest->headers
        ->set('Surrogate-Capability', $request->headers
        ->get('Surrogate-Capability'));
    }
    if ($session = $request
      ->getSession()) {
      $subRequest
        ->setSession($session);
    }
    return $subRequest;
  }

  /**
   * {@inheritdoc}
   */
  public function getName() {
    return 'inline';
  }

}

Members

Name	Modifiers	Type	Description	Overrides
InlineFragmentRenderer::$dispatcher	private	property
InlineFragmentRenderer::$kernel	private	property
InlineFragmentRenderer::createSubRequest	protected	function
InlineFragmentRenderer::getName	public	function	Gets the name of the strategy. Overrides FragmentRendererInterface::getName
InlineFragmentRenderer::render	public	function	Additional available options: Overrides FragmentRendererInterface::render
InlineFragmentRenderer::__construct	public	function	Constructor.
RoutableFragmentRenderer::$fragmentPath	private	property
RoutableFragmentRenderer::checkNonScalar	private	function
RoutableFragmentRenderer::generateFragmentUri	protected	function	Generates a fragment URI for a given controller.
RoutableFragmentRenderer::setFragmentPath	public	function	Sets the fragment path that triggers the fragment listener.