/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-helpers/src/UrlHelper.php
public function getRouteResult() : ?RouteResult
{
return $this->result;
}
/**
* Internal accessor for retrieving the base path.
*/
public function getBasePath() : string
{
return $this->basePath;
}
/**
* @throws Exception\RuntimeException if current result is a routing failure.
*/
private function generateUriFromResult(array $params, RouteResult $result, array $routerOptions) : string
{
if ($result->isFailure()) {
throw new Exception\RuntimeException(
'Attempting to use matched result when routing failed; aborting'
);
}
$name = $result->getMatchedRouteName();
$params = array_merge($result->getMatchedParams(), $params);
return $this->router->generateUri($name, $params, $routerOptions);
}
/**
* Merge route result params and provided parameters.
*
* If the route result represents a routing failure, returns the params
* verbatim.
*
* If the route result does not represent the same route name requested,
* returns the params verbatim.
*
* Otherwise, merges the route result params with those provided at
* invocation, with the latter having precedence.
Arguments
"Attempting to use matched result when routing failed; aborting"
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-helpers/src/UrlHelper.php
string $fragmentIdentifier = null,
array $options = []
) : string {
$result = $this->getRouteResult();
if ($routeName === null && $result === null) {
throw new Exception\RuntimeException(
'Attempting to use matched result when none was injected; aborting'
);
}
$basePath = $this->getBasePath();
if ($basePath === '/') {
$basePath = '';
}
// Get the options to be passed to the router
$routerOptions = $options['router'] ?? [];
if ($routeName === null) {
$path = $basePath . $this->generateUriFromResult($routeParams, $result, $routerOptions);
$path = $this->appendQueryStringArguments($path, $queryParams);
$path = $this->appendFragment($path, $fragmentIdentifier);
return $path;
}
$reuseResultParams = ! isset($options['reuse_result_params']) || (bool) $options['reuse_result_params'];
if ($result && $reuseResultParams) {
// Merge RouteResult with the route parameters
$routeParams = $this->mergeParams($routeName, $result, $routeParams);
}
// Generate the route
$path = $basePath . $this->router->generateUri($routeName, $routeParams, $routerOptions);
// Append query string arguments and fragment, if present
$path = $this->appendQueryStringArguments($path, $queryParams);
$path = $this->appendFragment($path, $fragmentIdentifier);
return $path;
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-helpers/src/UrlHelper.php
$path = $this->appendFragment($path, $fragmentIdentifier);
return $path;
}
/**
* Generate a URL based on a given route.
*
* Proxies to __invoke().
*
* @see UrlHelper::__invoke()
*/
public function generate(
string $routeName = null,
array $routeParams = [],
array $queryParams = [],
string $fragmentIdentifier = null,
array $options = []
) : string {
return $this($routeName, $routeParams, $queryParams, $fragmentIdentifier, $options);
}
/**
* Inject a route result.
*
* When the route result is injected, the helper will use it to seed default
* parameters if the URL being generated is for the route that was matched.
*/
public function setRouteResult(RouteResult $result) : void
{
$this->result = $result;
}
/**
* Set the base path to prepend to a generated URI
*/
public function setBasePath(string $path) : void
{
$this->basePath = '/' . ltrim($path, '/');
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-zendviewrenderer/src/UrlHelper.php
$this->helper = $helper;
}
/**
* Proxies to `Zend\Expressive\Helper\UrlHelper::generate()`
*
* @param array $options Can have the following keys:
* - router (array): contains options to be passed to the router
* - reuse_result_params (bool): indicates if the current RouteResult
* parameters will be used, defaults to true
* @return string
*/
public function __invoke(
string $routeName = null,
array $routeParams = [],
array $queryParams = [],
string $fragmentIdentifier = null,
array $options = []
) {
return $this->helper->generate($routeName, $routeParams, $queryParams, $fragmentIdentifier, $options);
}
}
/home/rfages/rogerfages-peinture/www/vendor/laminas/laminas-view/src/Renderer/PhpRenderer.php
/**
* Overloading: proxy to helpers
*
* Proxies to the attached plugin manager to retrieve, return, and potentially
* execute helpers.
*
* * If the helper does not define __invoke, it will be returned
* * If the helper does define __invoke, it will be called as a functor
*
* @param string $method
* @param array $argv
* @return mixed
*/
public function __call($method, $argv)
{
$plugin = $this->plugin($method);
if (is_callable($plugin)) {
return call_user_func_array($plugin, $argv);
}
return $plugin;
}
/**
* Set filter chain
*
* @param FilterChain $filters
* @return PhpRenderer
*/
public function setFilterChain(FilterChain $filters)
{
$this->__filterChain = $filters;
return $this;
}
/**
* Retrieve filter chain for post-filtering script content
*
/home/rfages/rogerfages-peinture/www/vendor/laminas/laminas-view/src/Renderer/PhpRenderer.php
/**
* Overloading: proxy to helpers
*
* Proxies to the attached plugin manager to retrieve, return, and potentially
* execute helpers.
*
* * If the helper does not define __invoke, it will be returned
* * If the helper does define __invoke, it will be called as a functor
*
* @param string $method
* @param array $argv
* @return mixed
*/
public function __call($method, $argv)
{
$plugin = $this->plugin($method);
if (is_callable($plugin)) {
return call_user_func_array($plugin, $argv);
}
return $plugin;
}
/**
* Set filter chain
*
* @param FilterChain $filters
* @return PhpRenderer
*/
public function setFilterChain(FilterChain $filters)
{
$this->__filterChain = $filters;
return $this;
}
/**
* Retrieve filter chain for post-filtering script content
*
/home/rfages/rogerfages-peinture/www/src/App/templates/layout/default.phtml
<?php
// If preload css
// $this->headLink(['rel' => 'preload', 'as' => 'style', 'href' => '/assets/css/master.css'])
// ->headLink(['rel' => 'preload', 'as' => 'style', 'href' => '/assets/css/responsive.css'])
// ->headLink(['rel' => 'preload', 'as' => 'style', 'href' => '/lib/noty.css'])
// ->headLink(['rel' => 'preload', 'as' => 'style', 'href' => '/assets/css/custom.css']);
// ->prependStylesheet('/lib/fontawesome/css/all.css')
// ->prependStylesheet('/assets/css/master-origin.css')
$this->headLink()
->prependStylesheet('/assets/css/master.css')
->prependStylesheet('/assets/css/responsive.css')
->prependStylesheet('/lib/noty.css')
->prependStylesheet('/assets/css/custom.css');
if ($this->url() == '/demo') {
$this->headLink()
// ->prependStylesheet('https://cdnjs.cloudflare.com/ajax/libs/Swiper/4.4.6/css/swiper.min.css')
->prependStylesheet('https://cdn.jsdelivr.net/npm/swiper@9/swiper-bundle.min.css')
->prependStylesheet('/assets/css/demo-slider.css');
}
$this->inlinescript()
->prependFile('assets/js/master.js')
->prependFile('assets/js/plugins.js')
->prependFile('lib/cubeportfolio/js/jquery.cubeportfolio.min.js')
->prependFile('assets/js/jquery.min.js');
?>
<!DOCTYPE html>
<html lang="fr">
<head>
<!-- Google Tag Manager -->
<script>
(function(w, d, s, l, i) {
w[l] = w[l] || [];
w[l].push({
'gtm.start': new Date().getTime(),
event: 'gtm.js'
/home/rfages/rogerfages-peinture/www/vendor/laminas/laminas-view/src/Renderer/PhpRenderer.php
$__vars = $this->vars()->getArrayCopy();
if (array_key_exists('this', $__vars)) {
unset($__vars['this']);
}
extract($__vars);
unset($__vars); // remove $__vars from local scope
$this->__content = '';
while ($this->__template = array_pop($this->__templates)) {
$this->__file = $this->resolver($this->__template);
if (! $this->__file) {
throw new Exception\RuntimeException(sprintf(
'%s: Unable to render template "%s"; resolver could not resolve to a file',
__METHOD__,
$this->__template
));
}
try {
ob_start();
$includeReturn = include $this->__file;
$this->__content = ob_get_clean();
} catch (\Throwable $ex) {
ob_end_clean();
throw $ex;
} catch (\Exception $ex) { // @TODO clean up once PHP 7 requirement is enforced
ob_end_clean();
throw $ex;
}
if ($includeReturn === false && empty($this->__content)) {
throw new Exception\UnexpectedValueException(sprintf(
'%s: Unable to render template "%s"; file include failed',
__METHOD__,
$this->__file
));
}
}
$this->setVars(array_pop($this->__varsCache));
if ($this->__filterChain instanceof FilterChain) {
Arguments
"/home/rfages/rogerfages-peinture/www/src/App/templates/layout/default.phtml"
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-zendviewrenderer/src/ZendViewRenderer.php
$child = $this->mergeViewModel($child->getTemplate(), $child);
if ($child !== $root) {
$viewModelHelper = $renderer->plugin(Helper\ViewModel::class);
$viewModelHelper->setRoot($root);
}
$result = $this->renderModel($child, $renderer, $root);
if ($child->isAppend()) {
$oldResult = $model->{$capture};
$model->setVariable($capture, $oldResult . $result);
continue;
}
$model->setVariable($capture, $result);
}
return $renderer->render($model);
}
/**
* Returns a PhpRenderer object
*/
private function createRenderer() : PhpRenderer
{
$renderer = new PhpRenderer();
$renderer->setResolver($this->getDefaultResolver());
return $renderer;
}
/**
* Get the default resolver
*/
private function getDefaultResolver() : AggregateResolver
{
$resolver = new AggregateResolver();
$this->injectNamespacedResolver($resolver);
return $resolver;
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-zendviewrenderer/src/ZendViewRenderer.php
* - a string layout template name
* - a Zend\View\Model\ModelInterface instance
*
* Layouts specified with $params take precedence over layouts passed to
* the constructor.
*
* @param array|ModelInterface|object $params
*/
public function render(string $name, $params = []) : string
{
$viewModel = $params instanceof ModelInterface
? $this->mergeViewModel($name, $params)
: $this->createModel($name, $params);
$useLayout = false !== $viewModel->getVariable('layout', null);
if ($useLayout) {
$viewModel = $this->prepareLayout($viewModel);
}
return $this->renderModel($viewModel, $this->renderer);
}
/**
* Add a path for templates.
*/
public function addPath(string $path, string $namespace = null) : void
{
$this->resolver->addPath($path, $namespace);
}
/**
* Get the template directories
*
* @return TemplatePath[]
*/
public function getPaths() : array
{
$paths = [];
foreach ($this->resolver->getPaths() as $namespace => $namespacedPaths) {
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Handler/NotFoundHandler.php
$request->getMethod(),
(string) $request->getUri()
));
return $response;
}
/**
* Generates a response using a template.
*
* Template will receive the current request via the "request" variable.
*/
private function generateTemplatedResponse(
TemplateRendererInterface $renderer,
ServerRequestInterface $request
) : ResponseInterface {
$response = ($this->responseFactory)()->withStatus(StatusCodeInterface::STATUS_NOT_FOUND);
$response->getBody()->write(
$renderer->render($this->template, ['request' => $request, 'layout' => $this->layout])
);
return $response;
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Handler/NotFoundHandler.php
$this->responseFactory = function () use ($responseFactory) : ResponseInterface {
return $responseFactory();
};
$this->renderer = $renderer;
$this->template = $template;
$this->layout = $layout;
}
/**
* Creates and returns a 404 response.
*
* @param ServerRequestInterface $request Passed to internal handler
*/
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->renderer === null) {
return $this->generatePlainTextResponse($request);
}
return $this->generateTemplatedResponse($this->renderer, $request);
}
/**
* Generates a plain text response indicating the request method and URI.
*/
private function generatePlainTextResponse(ServerRequestInterface $request) : ResponseInterface
{
$response = ($this->responseFactory)()->withStatus(StatusCodeInterface::STATUS_NOT_FOUND);
$response->getBody()
->write(sprintf(
'Cannot %s %s',
$request->getMethod(),
(string) $request->getUri()
));
return $response;
}
/**
* Generates a response using a template.
/home/rfages/rogerfages-peinture/www/src/App/src/Middleware/AuthorizationMiddleware.php
class AuthorizationMiddleware implements MiddlewareInterface
{
private $notFoundHandler;
private $redirect;
public function __construct(NotFoundHandler $notFoundHandler, string $redirect)
{
$this->notFoundHandler = $notFoundHandler;
$this->redirect = $redirect;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
// 404 check early
$routeResult = $request->getAttribute(RouteResult::class);
if ($routeResult->isFailure()) {
return $this->notFoundHandler->handle($request, $handler);
}
$session = $request->getAttribute(SessionMiddleware::SESSION_ATTRIBUTE);
// No Session data
if (! $session->has(UserInterface::class)) {
$user = '';
$roles = [
'guest'
];
$request = $request->withAttribute(UserInterface::class, new DefaultUser($user, $roles));
$response = $handler->handle($request);
if ($request->getUri()->getPath() === $this->redirect || $response->getStatusCode() !== 403) {
return $response;
}
return new RedirectResponse($this->redirect);
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-helpers/src/UrlHelperMiddleware.php
private $helper;
public function __construct(UrlHelper $helper)
{
$this->helper = $helper;
}
/**
* Inject the UrlHelper instance with a RouteResult, if present as a request attribute.
* Injects the helper, and then dispatches the next middleware.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$result = $request->getAttribute(RouteResult::class, false);
if ($result instanceof RouteResult) {
$this->helper->setRouteResult($result);
}
return $handler->handle($request);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-router/src/Middleware/MethodNotAllowedMiddleware.php
class MethodNotAllowedMiddleware implements MiddlewareInterface
{
/**
* @var callable
*/
private $responseFactory;
public function __construct(callable $responseFactory)
{
// Factories is wrapped in a closure in order to enforce return type safety.
$this->responseFactory = function () use ($responseFactory) : ResponseInterface {
return $responseFactory();
};
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$routeResult = $request->getAttribute(RouteResult::class);
if (! $routeResult || ! $routeResult->isMethodFailure()) {
return $handler->handle($request);
}
return ($this->responseFactory)()
->withStatus(StatusCode::STATUS_METHOD_NOT_ALLOWED)
->withHeader('Allow', implode(',', $routeResult->getAllowedMethods()));
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-router/src/Middleware/ImplicitOptionsMiddleware.php
/**
* @param callable $responseFactory A factory capable of returning an
* empty ResponseInterface instance to return for implicit OPTIONS
* requests.
*/
public function __construct(callable $responseFactory)
{
// Factories is wrapped in a closure in order to enforce return type safety.
$this->responseFactory = function () use ($responseFactory) : ResponseInterface {
return $responseFactory();
};
}
/**
* Handle an implicit OPTIONS request.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
if ($request->getMethod() !== RequestMethod::METHOD_OPTIONS) {
return $handler->handle($request);
}
$result = $request->getAttribute(RouteResult::class);
if (! $result) {
return $handler->handle($request);
}
if ($result->isFailure() && ! $result->isMethodFailure()) {
return $handler->handle($request);
}
if ($result->getMatchedRoute()) {
return $handler->handle($request);
}
$allowedMethods = $result->getAllowedMethods();
return ($this->responseFactory)()->withHeader('Allow', implode(',', $allowedMethods));
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-router/src/Middleware/ImplicitHeadMiddleware.php
{
$this->router = $router;
// Factory is wrapped in closur in order to enforce return type safety.
$this->streamFactory = function () use ($streamFactory) : StreamInterface {
return $streamFactory();
};
}
/**
* Handle an implicit HEAD request.
*
* If the route allows GET requests, dispatches as a GET request and
* resets the response body to be empty; otherwise, creates a new empty
* response.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
if ($request->getMethod() !== RequestMethod::METHOD_HEAD) {
return $handler->handle($request);
}
$result = $request->getAttribute(RouteResult::class);
if (! $result) {
return $handler->handle($request);
}
if ($result->getMatchedRoute()) {
return $handler->handle($request);
}
$routeResult = $this->router->match($request->withMethod(RequestMethod::METHOD_GET));
if ($routeResult->isFailure()) {
return $handler->handle($request);
}
// Copy matched parameters like RouteMiddleware does
foreach ($routeResult->getMatchedParams() as $param => $value) {
$request = $request->withAttribute($param, $value);
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-router/src/Middleware/RouteMiddleware.php
public function __construct(RouterInterface $router)
{
$this->router = $router;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$result = $this->router->match($request);
// Inject the actual route result, as well as individual matched parameters.
$request = $request->withAttribute(RouteResult::class, $result);
if ($result->isSuccess()) {
foreach ($result->getMatchedParams() as $param => $value) {
$request = $request->withAttribute($param, $value);
}
}
return $handler->handle($request);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-flash/src/FlashMessageMiddleware.php
|| ! in_array(FlashMessagesInterface::class, class_implements($flashMessagesClass), true)
) {
throw Exception\InvalidFlashMessagesImplementationException::forClass($flashMessagesClass);
}
$this->flashMessageFactory = [$flashMessagesClass, 'createFromSession'];
$this->sessionKey = $sessionKey;
$this->attributeKey = $attributeKey;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$session = $request->getAttribute(SessionMiddleware::SESSION_ATTRIBUTE, false);
if (! $session instanceof SessionInterface) {
throw Exception\MissingSessionException::forMiddleware($this);
}
$flashMessages = ($this->flashMessageFactory)($session, $this->sessionKey);
return $handler->handle($request->withAttribute($this->attributeKey, $flashMessages));
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-session/src/SessionMiddleware.php
use Psr\Http\Server\RequestHandlerInterface;
class SessionMiddleware implements MiddlewareInterface
{
public const SESSION_ATTRIBUTE = 'session';
/**
* @var SessionPersistenceInterface
*/
private $persistence;
public function __construct(SessionPersistenceInterface $persistence)
{
$this->persistence = $persistence;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$session = new LazySession($this->persistence, $request);
$response = $handler->handle($request->withAttribute(self::SESSION_ATTRIBUTE, $session));
return $this->persistence->persistSession($session, $response);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive-helpers/src/ServerUrlMiddleware.php
{
/**
* @var ServerUrlHelper
*/
private $helper;
public function __construct(ServerUrlHelper $helper)
{
$this->helper = $helper;
}
/**
* Inject the ServerUrlHelper instance with the request URI.
* Injects the ServerUrlHelper with the incoming request URI, and then invoke
* the next middleware.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$this->helper->setUri($request->getUri());
return $handler->handle($request);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Middleware/ErrorHandler.php
/**
* Middleware to handle errors and exceptions in layers it wraps.
*
* Adds an error handler that will convert PHP errors to ErrorException
* instances.
*
* Internally, wraps the call to $next() in a try/catch block, catching
* all PHP Throwables.
*
* When an exception is caught, an appropriate error response is created
* and returned instead; otherwise, the response returned by $next is
* used.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
set_error_handler($this->createErrorHandler());
try {
$response = $handler->handle($request);
} catch (Throwable $e) {
$response = $this->handleThrowable($e, $request);
}
restore_error_handler();
return $response;
}
/**
* Handles all throwables, generating and returning a response.
*
* Passes the error, request, and response prototype to createErrorResponse(),
* triggers all listeners with the same arguments (but using the response
* returned from createErrorResponse()), and then returns the response.
*/
private function handleThrowable(Throwable $e, ServerRequestInterface $request) : ResponseInterface
{
$generator = $this->responseGenerator;
$response = $generator($e, $request, ($this->responseFactory)());
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/MiddlewarePipe.php
* If the pipeline is empty at the time this method is invoked, it will
* raise an exception.
*
* @throws Exception\EmptyPipelineException if no middleware is present in
* the instance in order to process the request.
*/
public function handle(ServerRequestInterface $request) : ResponseInterface
{
return $this->process($request, new EmptyPipelineHandler(__CLASS__));
}
/**
* PSR-15 middleware invocation.
*
* Executes the internal pipeline, passing $handler as the "final
* handler" in cases when the pipeline exhausts itself.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
return (new Next($this->pipeline, $handler))->handle($request);
}
/**
* Attach middleware to the pipeline.
*/
public function pipe(MiddlewareInterface $middleware) : void
{
$this->pipeline->enqueue($middleware);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-stratigility/src/MiddlewarePipe.php
}
/**
* Handle an incoming request.
*
* Attempts to handle an incoming request by doing the following:
*
* - Cloning itself, to produce a request handler.
* - Dequeuing the first middleware in the cloned handler.
* - Processing the first middleware using the request and the cloned handler.
*
* If the pipeline is empty at the time this method is invoked, it will
* raise an exception.
*
* @throws Exception\EmptyPipelineException if no middleware is present in
* the instance in order to process the request.
*/
public function handle(ServerRequestInterface $request) : ResponseInterface
{
return $this->process($request, new EmptyPipelineHandler(__CLASS__));
}
/**
* PSR-15 middleware invocation.
*
* Executes the internal pipeline, passing $handler as the "final
* handler" in cases when the pipeline exhausts itself.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
return (new Next($this->pipeline, $handler))->handle($request);
}
/**
* Attach middleware to the pipeline.
*/
public function pipe(MiddlewareInterface $middleware) : void
{
$this->pipeline->enqueue($middleware);
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-httphandlerrunner/src/RequestHandlerRunner.php
$this->serverRequestErrorResponseGenerator =
function (Throwable $exception) use ($serverRequestErrorResponseGenerator) : ResponseInterface {
return $serverRequestErrorResponseGenerator($exception);
};
}
/**
* Run the application
*/
public function run() : void
{
try {
$request = ($this->serverRequestFactory)();
} catch (Throwable $e) {
// Error in generating the request
$this->emitMarshalServerRequestException($e);
return;
}
$response = $this->handler->handle($request);
$this->emitter->emit($response);
}
private function emitMarshalServerRequestException(Throwable $exception) : void
{
$response = ($this->serverRequestErrorResponseGenerator)($exception);
$this->emitter->emit($response);
}
}
/home/rfages/rogerfages-peinture/www/vendor/zendframework/zend-expressive/src/Application.php
return $this->pipeline->handle($request);
}
/**
* Proxies to composed pipeline to process.
* {@inheritDocs}
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
return $this->pipeline->process($request, $handler);
}
/**
* Run the application.
*
* Proxies to the RequestHandlerRunner::run() method.
*/
public function run() : void
{
$this->runner->run();
}
/**
* Pipe middleware to the pipeline.
*
* If two arguments are present, they are passed to pipe(), after first
* passing the second argument to the factory's prepare() method.
*
* If only one argument is presented, it is passed to the factory prepare()
* method.
*
* The resulting middleware, in both cases, is piped to the pipeline.
*
* @param string|array|callable|MiddlewareInterface|RequestHandlerInterface $middlewareOrPath
* Either the middleware to pipe, or the path to segregate the $middleware
* by, via a PathMiddlewareDecorator.
* @param null|string|array|callable|MiddlewareInterface|RequestHandlerInterface $middleware
* If present, middleware or request handler to segregate by the path
* specified in $middlewareOrPath.
*/
/home/rfages/rogerfages-peinture/www/public/index.php
chdir(dirname(__DIR__));
require 'vendor/autoload.php';
/**
* Self-called anonymous function that creates its own scope and keep the global namespace clean.
*/
(function () {
/** @var \Psr\Container\ContainerInterface $container */
$container = require 'config/container.php';
/** @var \Zend\Expressive\Application $app */
$app = $container->get(\Zend\Expressive\Application::class);
$factory = $container->get(\Zend\Expressive\MiddlewareFactory::class);
// Execute programmatic/declarative middleware pipeline and routing
// configuration statements
(require 'config/pipeline.php')($app, $factory, $container);
(require 'config/routes.php')($app, $factory, $container);
$app->run();
})();
/home/rfages/rogerfages-peinture/www/public/index.php
require 'vendor/autoload.php';
/**
* Self-called anonymous function that creates its own scope and keep the global namespace clean.
*/
(function () {
/** @var \Psr\Container\ContainerInterface $container */
$container = require 'config/container.php';
/** @var \Zend\Expressive\Application $app */
$app = $container->get(\Zend\Expressive\Application::class);
$factory = $container->get(\Zend\Expressive\MiddlewareFactory::class);
// Execute programmatic/declarative middleware pipeline and routing
// configuration statements
(require 'config/pipeline.php')($app, $factory, $container);
(require 'config/routes.php')($app, $factory, $container);
$app->run();
})();