the whole shebang

vendor/symfony/http-kernel/Symfony/Component/HttpKernel/Fragment/EsiFragmentRenderer.php

@@ -0,0 +1,84 @@
+<?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\HttpKernel\Fragment;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Controller\ControllerReference;
+use Symfony\Component\HttpKernel\HttpCache\Esi;
+
+/**
+ * Implements the ESI rendering strategy.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class EsiFragmentRenderer extends RoutableFragmentRenderer
+{
+    private $esi;
+    private $inlineStrategy;
+
+    /**
+     * Constructor.
+     *
+     * The "fallback" strategy when ESI is not available should always be an
+     * instance of InlineFragmentRenderer.
+     *
+     * @param Esi                    $esi            An Esi instance
+     * @param InlineFragmentRenderer $inlineStrategy The inline strategy to use when ESI is not supported
+     */
+    public function __construct(Esi $esi, InlineFragmentRenderer $inlineStrategy)
+    {
+        $this->esi = $esi;
+        $this->inlineStrategy = $inlineStrategy;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Note that if the current Request has no ESI capability, this method
+     * falls back to use the inline rendering strategy.
+     *
+     * Additional available options:
+     *
+     *  * alt: an alternative URI to render in case of an error
+     *  * comment: a comment to add when returning an esi:include tag
+     *
+     * @see Symfony\Component\HttpKernel\HttpCache\ESI
+     */
+    public function render($uri, Request $request, array $options = array())
+    {
+        if (!$this->esi->hasSurrogateEsiCapability($request)) {
+            return $this->inlineStrategy->render($uri, $request, $options);
+        }
+
+        if ($uri instanceof ControllerReference) {
+            $uri = $this->generateFragmentUri($uri, $request);
+        }
+
+        $alt = isset($options['alt']) ? $options['alt'] : null;
+        if ($alt instanceof ControllerReference) {
+            $alt = $this->generateFragmentUri($alt, $request);
+        }
+
+        $tag = $this->esi->renderIncludeTag($uri, $alt, isset($options['ignore_errors']) ? $options['ignore_errors'] : false, isset($options['comment']) ? $options['comment'] : '');
+
+        return new Response($tag);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return 'esi';
+    }
+}

vendor/symfony/http-kernel/Symfony/Component/HttpKernel/Fragment/FragmentHandler.php

@@ -0,0 +1,127 @@
+<?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\HttpKernel\Fragment;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+use Symfony\Component\HttpKernel\Controller\ControllerReference;
+
+/**
+ * Renders a URI that represents a resource fragment.
+ *
+ * This class handles the rendering of resource fragments that are included into
+ * a main resource. The handling of the rendering is managed by specialized renderers.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @see FragmentRendererInterface
+ */
+class FragmentHandler
+{
+    private $debug;
+    private $renderers;
+    private $request;
+
+    /**
+     * Constructor.
+     *
+     * @param FragmentRendererInterface[] $renderers An array of FragmentRendererInterface instances
+     * @param Boolean                     $debug     Whether the debug mode is enabled or not
+     */
+    public function __construct(array $renderers = array(), $debug = false)
+    {
+        $this->renderers = array();
+        foreach ($renderers as $renderer) {
+            $this->addRenderer($renderer);
+        }
+        $this->debug = $debug;
+    }
+
+    /**
+     * Adds a renderer.
+     *
+     * @param FragmentRendererInterface $renderer A FragmentRendererInterface instance
+     */
+    public function addRenderer(FragmentRendererInterface $renderer)
+    {
+        $this->renderers[$renderer->getName()] = $renderer;
+    }
+
+    /**
+     * Sets the current Request.
+     *
+     * @param Request $request The current Request
+     */
+    public function setRequest(Request $request = null)
+    {
+        $this->request = $request;
+    }
+
+    /**
+     * Renders a URI and returns the Response content.
+     *
+     * Available options:
+     *
+     *  * ignore_errors: true to return an empty string in case of an error
+     *
+     * @param string|ControllerReference $uri      A URI as a string or a ControllerReference instance
+     * @param string                     $renderer The renderer name
+     * @param array                      $options  An array of options
+     *
+     * @return string|null The Response content or null when the Response is streamed
+     *
+     * @throws \InvalidArgumentException when the renderer does not exist
+     * @throws \RuntimeException         when the Response is not successful
+     */
+    public function render($uri, $renderer = 'inline', array $options = array())
+    {
+        if (!isset($options['ignore_errors'])) {
+            $options['ignore_errors'] = !$this->debug;
+        }
+
+        if (!isset($this->renderers[$renderer])) {
+            throw new \InvalidArgumentException(sprintf('The "%s" renderer does not exist.', $renderer));
+        }
+
+        if (null === $this->request) {
+            throw new \LogicException('Rendering a fragment can only be done when handling a master Request.');
+        }
+
+        return $this->deliver($this->renderers[$renderer]->render($uri, $this->request, $options));
+    }
+
+    /**
+     * Delivers the Response as a string.
+     *
+     * When the Response is a StreamedResponse, the content is streamed immediately
+     * instead of being returned.
+     *
+     * @param Response $response A Response instance
+     *
+     * @return string|null The Response content or null when the Response is streamed
+     *
+     * @throws \RuntimeException when the Response is not successful
+     */
+    protected function deliver(Response $response)
+    {
+        if (!$response->isSuccessful()) {
+            throw new \RuntimeException(sprintf('Error when rendering "%s" (Status code is %s).', $this->request->getUri(), $response->getStatusCode()));
+        }
+
+        if (!$response instanceof StreamedResponse) {
+            return $response->getContent();
+        }
+
+        $response->sendContent();
+    }
+}

vendor/symfony/http-kernel/Symfony/Component/HttpKernel/Fragment/FragmentRendererInterface.php

@@ -0,0 +1,43 @@
+<?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\HttpKernel\Fragment;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ControllerReference;
+
+/**
+ * Interface implemented by all rendering strategies.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @see Symfony\Component\HttpKernel\FragmentRenderer
+ */
+interface FragmentRendererInterface
+{
+    /**
+     * Renders a URI and returns the Response content.
+     *
+     * @param string|ControllerReference $uri     A URI as a string or a ControllerReference instance
+     * @param Request                    $request A Request instance
+     * @param array                      $options An array of options
+     *
+     * @return Response A Response instance
+     */
+    public function render($uri, Request $request, array $options = array());
+
+    /**
+     * Gets the name of the strategy.
+     *
+     * @return string The strategy name
+     */
+    public function getName();
+}

vendor/symfony/http-kernel/Symfony/Component/HttpKernel/Fragment/HIncludeFragmentRenderer.php

@@ -0,0 +1,162 @@
+<?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\HttpKernel\Fragment;
+
+if (!defined('ENT_SUBSTITUTE')) {
+    define('ENT_SUBSTITUTE', 8);
+}
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Templating\EngineInterface;
+use Symfony\Component\HttpKernel\Controller\ControllerReference;
+use Symfony\Component\HttpKernel\UriSigner;
+
+/**
+ * Implements the Hinclude rendering strategy.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class HIncludeFragmentRenderer extends RoutableFragmentRenderer
+{
+    private $globalDefaultTemplate;
+    private $signer;
+    private $templating;
+    private $charset;
+
+    /**
+     * Constructor.
+     *
+     * @param EngineInterface|\Twig_Environment $templating            An EngineInterface or a \Twig_Environment instance
+     * @param UriSigner                         $signer                A UriSigner instance
+     * @param string                            $globalDefaultTemplate The global default content (it can be a template name or the content)
+     * @param string                            $charset
+     */
+    public function __construct($templating = null, UriSigner $signer = null, $globalDefaultTemplate = null, $charset = 'utf-8')
+    {
+        $this->setTemplating($templating);
+        $this->globalDefaultTemplate = $globalDefaultTemplate;
+        $this->signer = $signer;
+        $this->charset = $charset;
+    }
+
+    /**
+     * Sets the templating engine to use to render the default content.
+     *
+     * @param EngineInterface|\Twig_Environment|null $templating An EngineInterface or a \Twig_Environment instance
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function setTemplating($templating)
+    {
+        if (null !== $templating && !$templating instanceof EngineInterface && !$templating instanceof \Twig_Environment) {
+            throw new \InvalidArgumentException('The hinclude rendering strategy needs an instance of \Twig_Environment or Symfony\Component\Templating\EngineInterface');
+        }
+
+        $this->templating = $templating;
+    }
+
+    /**
+     * Checks if a templating engine has been set.
+     *
+     * @return Boolean true if the templating engine has been set, false otherwise
+     */
+    public function hasTemplating()
+    {
+        return null !== $this->templating;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Additional available options:
+     *
+     *  * default:    The default content (it can be a template name or the content)
+     *  * id:         An optional hx:include tag id attribute
+     *  * attributes: An optional array of hx:include tag attributes
+     */
+    public function render($uri, Request $request, array $options = array())
+    {
+        if ($uri instanceof ControllerReference) {
+            if (null === $this->signer) {
+                throw new \LogicException('You must use a proper URI when using the Hinclude rendering strategy or set a URL signer.');
+            }
+
+            $uri = $this->signer->sign($this->generateFragmentUri($uri, $request));
+        }
+
+        // We need to replace ampersands in the URI with the encoded form in order to return valid html/xml content.
+        $uri = str_replace('&', '&amp;', $uri);
+
+        $template = isset($options['default']) ? $options['default'] : $this->globalDefaultTemplate;
+        if (null !== $this->templating && $template && $this->templateExists($template)) {
+            $content = $this->templating->render($template);
+        } else {
+            $content = $template;
+        }
+
+        $attributes = isset($options['attributes']) && is_array($options['attributes']) ? $options['attributes'] : array();
+        if (isset($options['id']) && $options['id']) {
+            $attributes['id'] = $options['id'];
+        }
+        $renderedAttributes = '';
+        if (count($attributes) > 0) {
+            foreach ($attributes as $attribute => $value) {
+                $renderedAttributes .= sprintf(
+                    ' %s="%s"',
+                    htmlspecialchars($attribute, ENT_QUOTES | ENT_SUBSTITUTE, $this->charset, false),
+                    htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, $this->charset, false)
+                );
+            }
+        }
+
+        return new Response(sprintf('<hx:include src="%s"%s>%s</hx:include>', $uri, $renderedAttributes, $content));
+    }
+
+    /**
+     * @param string $template
+     *
+     * @return boolean
+     */
+    private function templateExists($template)
+    {
+        if ($this->templating instanceof EngineInterface) {
+            try {
+                return $this->templating->exists($template);
+            } catch (\InvalidArgumentException $e) {
+                return false;
+            }
+        }
+
+        $loader = $this->templating->getLoader();
+        if ($loader instanceof \Twig_ExistsLoaderInterface) {
+            return $loader->exists($template);
+        }
+
+        try {
+            $loader->getSource($template);
+
+            return true;
+        } catch (\Twig_Error_Loader $e) {
+        }
+
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return 'hinclude';
+    }
+}

vendor/symfony/http-kernel/Symfony/Component/HttpKernel/Fragment/InlineFragmentRenderer.php

@@ -0,0 +1,152 @@
+<?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\HttpKernel\Fragment;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\HttpKernel\Controller\ControllerReference;
+use Symfony\Component\HttpKernel\KernelEvents;
+use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+
+/**
+ * Implements the inline rendering strategy where the Request is rendered by the current HTTP kernel.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class InlineFragmentRenderer extends RoutableFragmentRenderer
+{
+    private $kernel;
+    private $dispatcher;
+
+    /**
+     * Constructor.
+     *
+     * @param HttpKernelInterface $kernel A HttpKernelInterface 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 overriden by the user
+            foreach (array('_format', '_locale') as $key) {
+                if (isset($attributes[$key])) {
+                    $reference->attributes[$key] = $attributes[$key];
+                }
+            }
+
+            $uri = $this->generateFragmentUri($uri, $request);
+            $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
+            while (ob_get_level() > $level) {
+                ob_get_clean();
+            }
+
+            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';
+    }
+}

vendor/symfony/http-kernel/Symfony/Component/HttpKernel/Fragment/RoutableFragmentRenderer.php

@@ -0,0 +1,74 @@
+<?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\HttpKernel\Fragment;
+
+use Symfony\Component\HttpKernel\Controller\ControllerReference;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\EventListener\FragmentListener;
+
+/**
+ * Adds the possibility to generate a fragment URI for a given Controller.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+abstract class RoutableFragmentRenderer implements FragmentRendererInterface
+{
+    private $fragmentPath = '/_fragment';
+
+    /**
+     * Sets the fragment path that triggers the fragment listener.
+     *
+     * @param string $path The path
+     *
+     * @see FragmentListener
+     */
+    public function setFragmentPath($path)
+    {
+        $this->fragmentPath = $path;
+    }
+
+    /**
+     * Generates a fragment URI for a given controller.
+     *
+     * @param ControllerReference  $reference A ControllerReference instance
+     * @param Request              $request   A Request instance
+     * @param Boolean              $absolute  Whether to generate an absolute URL or not
+     *
+     * @return string A fragment URI
+     */
+    protected function generateFragmentUri(ControllerReference $reference, Request $request, $absolute = false)
+    {
+        // We need to forward the current _format and _locale values as we don't have
+        // a proper routing pattern to do the job for us.
+        // This makes things inconsistent if you switch from rendering a controller
+        // to rendering a route if the route pattern does not contain the special
+        // _format and _locale placeholders.
+        if (!isset($reference->attributes['_format'])) {
+            $reference->attributes['_format'] = $request->getRequestFormat();
+        }
+        if (!isset($reference->attributes['_locale'])) {
+            $reference->attributes['_locale'] = $request->getLocale();
+        }
+
+        $reference->attributes['_controller'] = $reference->controller;
+
+        $reference->query['_path'] = http_build_query($reference->attributes, '', '&');
+
+        $path = $this->fragmentPath.'?'.http_build_query($reference->query, '', '&');
+
+        if ($absolute) {
+            return $request->getUriForPath($path);
+        }
+
+        return $request->getBaseUrl().$path;
+    }
+}