Vssl\Render\Resolver

Complexity

Total Complexity

19

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

95.12%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	getRequest()	0	4	1
B	resolve()	0	19	8
A	decodePage()	0	9	3
A	config()	0	18	4

<?php

namespace Vssl\Render;

use GuzzleHttp\Client;
use Journey\Cache\Adapters\LocalAdapter;
use Journey\Cache\CacheAdapterInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

class Resolver
{
    /**
     * The request object.
     *
     * @var \Psr\Http\Message\ServerRequestInterface
     */
    protected $request;

    /**
     * Configuration array.
     *
     * @var array
     */
    protected $config;

    /**
     * The page api object.
     *
     * @var \Vssl\Render\PageApi
     */
    protected $api;

    /**
     * Initialize a new Resolver
     */
    public function __construct(ServerRequestInterface $request, $config = false)
    {
        $this->request = $request;
        $this->config = is_array($config) ? static::config($config) : static::config();

$config is of type array, but the function expects a boolean.

        if (!$this->config['cache'] instanceof CacheAdapterInterface) {
            throw new ResolverException('Cache must implement \Journey\Cache\CacheAdapterInterface.');
        }
        $this->api = new PageApi($request, $this->config);
    }

    /**
     * Get a modified request message.
     *
     * @return \Psr\Http\Message\ServerRequestInterface
     */
    public function getRequest()
    {
        return $this->request->withAttribute('vssl-page', $this->resolve());
    }

    /**
     * Resolve the current page from WebStories. Returns a render able page or
     * false.
     *
     * @return array
     */
    public function resolve()
    {
        $response = $this->api->getPage($this->request->getUri()->getPath());
        if ($response && ($page = $this->decodePage($response))) {
            $status = $response->getStatusCode();
            return [
                'status' => $status,
                'data' => $page,
                'page' => (is_array($page) && $status == 200) ? new Renderer($this->config, $page) : $page,
                'opengraph' => (is_array($page) && $status == 200) ? new Metadata($this->config, $page) : $page,
                'type' => !empty($page['type']) ? $page['type'] : false
            ];
        }
        return [
            'status' => false,
            'error' => 'An unknown error occurred',
            'data' => []
        ];
    }

    /**
     * Decode the body of a particular request.
     *
     * @return mixed
     */
    public function decodePage(ResponseInterface $response)
    {
        $body = (string) $response->getBody();
        if ($response->getHeaderLine('Content-Type') == "application/json") {
            $page = json_decode($body, true);
            return !empty($page['exists']) ? $page['page'] : false;
        }
        return false;
    }

    /**
     * Configure the resolver.
     *
     * @return void
     */
    public static function config($assign = false)
    {
        static $config;

        if (is_array($assign) || !$config) {
            $config = array_merge([
                'cache' => null,
                'base_uri' => 'https://pages.vssl.io/',
                'required_fields' => [
                    'id',
                    'title',
                    'stripes'
                ],
                // 'templates' => 'your-directory'

50% of this comment could be valid code. Did you maybe forget this after debugging?

            ], $assign);
        }
        return $config ?: [];
    }
}