Enjoys\AssetsCollector\CollectStrategy\Strategy\OneFileStrategy

Complexity

Total Complexity

12

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

80.95%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	generateFilename()	0	3	1
A	isCacheValid()	0	6	2
A	__construct()	0	15	1
A	getFilePath()	0	3	1
A	init()	0	10	2
A	getFileUrl()	0	3	1
A	getResult()	0	23	4

<?php

namespace Enjoys\AssetsCollector\CollectStrategy\Strategy;

use Enjoys\AssetsCollector\Asset;
use Enjoys\AssetsCollector\CollectStrategy\StrategyAbstract;
use Enjoys\AssetsCollector\Content\Reader;
use Enjoys\AssetsCollector\Environment;
use Enjoys\AssetsCollector\Helpers;

class OneFileStrategy extends StrategyAbstract
{
    private int $cacheTime;
    private string $filePath;
    private string $fileUrl;
    private bool $fileCreated = false;
    /**
     * @var array{css: array<mixed>, js: array<mixed>}
     */
    private array $minifyOptions;

    /**
     * Build constructor.
     * @param Environment $environment
     * @param array<Asset> $assetsCollection
     * @param string $type
     * @throws \Exception
     */
    public function __construct(
        Environment $environment,
        array $assetsCollection,
        string $type
    ) {
        parent::__construct($environment, $assetsCollection, $type);

        $this->cacheTime = $environment->getCacheTime();
        $this->minifyOptions = $environment->getMinifyOptions();

        $filename = $this->generateFilename($type);

        $this->filePath = $environment->getCompileDir() . DIRECTORY_SEPARATOR . $filename;
        $this->fileUrl = $environment->getBaseUrl() . '/' . str_replace(DIRECTORY_SEPARATOR, '/', $filename);
        $this->init();
    }

    /**
     * @param string $type css|js
     * @return string
     */
    private function generateFilename(string $type): string
    {
        return '_' . $type . DIRECTORY_SEPARATOR . md5(serialize($this->assetsCollection)) . '.' . $type;
    }

    /**
     * @throws \Exception
     */
    private function init(): void
    {
        $path = pathinfo($this->filePath, PATHINFO_DIRNAME);
        Helpers::createDirectory($path);

It seems like $path can also be of type array; however, parameter $path of Enjoys\AssetsCollector\Helpers::createDirectory() does only seem to accept string, maybe add an additional type check?

        $this->logger->info(sprintf('Create directory %s', $path));

        if (!file_exists($this->filePath)) {
            Helpers::writeFile($this->filePath, '');
            $this->fileCreated = true;
            $this->logger->info(sprintf('Create new file %s', $this->filePath));
        }
    }

    private function isCacheValid(): bool
    {
        if ($this->fileCreated) {
            return false;
        }
        return (filemtime($this->filePath) + $this->cacheTime) > time();
    }

    /**
     * @return array<string>
     */
    public function getResult(): array
    {
        try {
            if ($this->isCacheValid()) {
                $this->logger->info(sprintf('Use cached file: %s', $this->filePath));
                $this->logger->info(sprintf('Return url: %s', $this->fileUrl));
                return [$this->fileUrl];
            }

            $output = '';

            foreach ($this->assetsCollection as $asset) {
                $output .= (new Reader($asset, $this->minifyOptions, $this->logger))->getContents();
            }

            Helpers::writeFile($this->filePath, $output);
            $this->logger->info(sprintf('Write to: %s', $this->filePath));
        } catch (\Exception $e) {
            $this->logger->notice($e->getMessage());
        }

        $this->logger->info(sprintf('Return url: %s', $this->fileUrl));
        return [$this->fileUrl];
    }

    /**
     * @return string
     */
    public function getFileUrl(): string
    {
        return $this->fileUrl;
    }

    /**
     * @return string
     */
    public function getFilePath(): string
    {
        return $this->filePath;
    }
}