Enjoys\AssetsCollector\Content\Reader

Complexity

Total Complexity

15

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Test Coverage

Coverage

73.08%

Importance

Changes	7
Bugs	2	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	getContents()	0	22	5
A	readFile()	0	20	3
A	readUrl()	0	19	2
A	setLogger()	0	3	1
A	getContent()	0	10	3

<?php

namespace Enjoys\AssetsCollector\Content;

use Enjoys\AssetsCollector\Asset;
use Enjoys\AssetsCollector\Content\Minify\MinifyFactory;
use Enjoys\AssetsCollector\Environment;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\GuzzleException;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

/**
 * Class Reader
 * @package Enjoys\AssetsCollector\Content
 */
class Reader
{
    /**
     * @var Asset
     */
    private Asset $asset;

    /**
     * @var false|string
     */
    private $content;
    /**
     * @var false|string
     */
    private $path;

    private Environment $environment;
    /**
     * @var LoggerInterface|NullLogger
     */
    private LoggerInterface $logger;

    /**
     * Reader constructor.
     * @param Asset $asset
     * @param Environment $environment
     * @param LoggerInterface|null $logger
     */
    public function __construct(
        Asset $asset,
        Environment $environment,
        LoggerInterface $logger = null
    ) {
        $this->environment = $environment;
        $this->asset = $asset;
        $this->logger = $logger ?? new NullLogger();
        $this->path = $this->asset->getPath();
        $this->content = $this->getContent();
    }

    /**
     * @throws \Exception
     */
    public function getContents(): string
    {
        if ($this->content === false || $this->path === false) {
            $this->logger->notice(sprintf('Nothing return: path is `%s`', $this->asset->getOrigPath()));
            return '';
        }

        if ($this->asset->isReplaceRelativeUrls()) {
            $replaceRelativeUrls = new ReplaceRelative($this->content, $this->path, $this->asset, $this->environment);

It seems like $this->content can also be of type true; however, parameter $content of Enjoys\AssetsCollector\Content\ReplaceRelative::__construct() does only seem to accept string, maybe add an additional type check?

It seems like $this->path can also be of type true; however, parameter $path of Enjoys\AssetsCollector\Content\ReplaceRelative::__construct() does only seem to accept string, maybe add an additional type check?

            $replaceRelativeUrls->setLogger($this->logger);
            $this->content = $replaceRelativeUrls->getContent();
        }

        if ($this->asset->isMinify()) {
            $this->content = MinifyFactory::minify(
                    $this->content,

It seems like $this->content can also be of type true; however, parameter $content of Enjoys\AssetsCollector\Content\Minify\MinifyFactory::minify() does only seem to accept string, maybe add an additional type check?

                    $this->asset->getType(),
                    $this->environment
                )->getContent() . "\n";
            $this->logger->info(sprintf('Minify: %s', $this->path));

It seems like $this->path can also be of type true; however, parameter $values of sprintf() does only seem to accept double|integer|string, maybe add an additional type check?

        }
        return $this->content;

The expression return $this->content could return the type true which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }


    /**
     * @return false|string
     */
    private function getContent()
    {
        if ($this->path === false) {
            return false;
        }

        if ($this->asset->isUrl()) {
            return $this->readUrl($this->path);

It seems like $this->path can also be of type true; however, parameter $url of Enjoys\AssetsCollector\Content\Reader::readUrl() does only seem to accept string, maybe add an additional type check?

        }
        return $this->readFile($this->path);

It seems like $this->path can also be of type true; however, parameter $filename of Enjoys\AssetsCollector\Content\Reader::readFile() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * @param string $url
     * @return false|string
     */
    private function readUrl(string $url)
    {
        try {
            $client = new Client(
                [
                    'verify' => false,
                    'allow_redirects' => true,
                    'headers' => [
                        'User-Agent' =>
                            'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36',
                    ]
                ]
            );
            $response = $client->get($url);
            $this->logger->info(sprintf('Read: %s', $url));
            return $response->getBody()->getContents();
        } catch (ClientException | GuzzleException $e) {
            $this->logger->notice($e->getMessage());
            return false;
        }
    }

    /**
     * @param string $filename
     * @return false|string
     */
    private function readFile(string $filename)
    {
        //Clear the most recent error
        error_clear_last();

        if (!file_exists($filename)) {
            $this->logger->notice(sprintf("Файла по указанному пути нет: %s", $filename));
            return false;
        }
        $content = @file_get_contents($filename);

        /** @var null|string[] $error */
        $error = error_get_last();
        if ($error !== null) {
            $this->logger->notice(sprintf("Ошибка чтения содержимого файла: %s", $error['message']));
            return false;
        }

        $this->logger->info(sprintf('Read: %s', $filename));
        return $content;
    }

    /**
     * @param LoggerInterface|NullLogger $logger
     */
    public function setLogger($logger): void
    {
        $this->logger = $logger;
    }
}