Enjoys\AssetsCollector\Content\Reader

Complexity

Total Complexity

12

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Test Coverage

Coverage

69.77%

Importance

Changes	2
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getContents()	0	18	4
A	readFile()	0	20	3
A	readUrl()	0	19	2
A	getContent()	0	7	2

<?php

namespace Enjoys\AssetsCollector\Content;

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

/**
 * Class Reader
 * @package Enjoys\AssetsCollector\Content
 */
class Reader
{
    use LoggerAwareTrait;

    /**
     * @var Asset
     */
    private Asset $asset;

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

    /**
     * @var array{css: array<mixed>, js: array<mixed>}
     */
    private array $minifyOptions;

    /**
     * Reader constructor.
     * @param Asset $asset
     * @param array{css: array<mixed>, js: array<mixed>} $minifyOptions
     * @param LoggerInterface|null $logger
     */
    public function __construct(Asset $asset, array $minifyOptions, LoggerInterface $logger = null)
    {
        $this->asset = $asset;
        $this->logger = $logger ?? new NullLogger();

        $this->content = $this->getContent();
        $this->minifyOptions = $minifyOptions;
    }

    public function getContents(): string
    {
        if (false === $this->content) {
            $this->logger->notice(sprintf('Nothing return: %s', $this->asset->getPath()));
            return '';
        }

        if ($this->asset->isUrl()) {
            $replaceRelativeUrls = new ReplaceRelativeUrls($this->content, $this->asset->getPath());

It seems like $this->content can also be of type true; however, parameter $content of Enjoys\AssetsCollector\Content\ReplaceRelativeUrls::__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, $this->asset->getType(), $this->minifyOptions)->getContent() . "\n";

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->logger->info(sprintf('Minify: %s', $this->asset->getPath()));
        }
        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->asset->isUrl()) {
            return $this->readUrl($this->asset->getPath());
        }

        return $this->readFile($this->asset->getPath());
    }

    /**
     * @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;
    }
}