Enjoys\AssetsCollector\Asset

Complexity

Total Complexity

17

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Test Coverage

Coverage

97.67%

Importance

Changes	4
Bugs	0	Features	2

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getPath()	0	3	1
A	setId()	0	3	1
A	getOrigPath()	0	3	1
A	getType()	0	3	1
A	checkIsUrl()	0	11	3
A	__construct()	0	10	1
A	isUrl()	0	3	1
A	isMinify()	0	3	1
A	normalizePath()	0	19	6
A	getId()	0	3	1

<?php

declare(strict_types=1);

namespace Enjoys\AssetsCollector;

use Enjoys\Traits\Options;

class Asset
{
    use Options;

    public const TYPE_CSS = 'css';
    public const TYPE_JS = 'js';

    public const PARAM_MINIFY = 'minify';
    private ?string $id = null;
    /**
     * @var false|string
     */
    private $path;
    private string $type;
    private bool $isUrl;
    private string $origPath;
    private bool $minify;


    /**
     * Asset constructor.
     * @param string $type
     * @param string $path
     * @param array<mixed> $params
     */
    public function __construct(string $type, string $path, array $params = [])
    {
        $this->setOptions($params);
        $this->type = $type;
        $this->origPath = $path;
        $this->path = $path;
        $this->minify = $this->getOption(self::PARAM_MINIFY, true);
        $this->isUrl = $this->checkIsUrl();

        $this->normalizePath();
    }

    private function normalizePath(): void
    {
        if ($this->isUrl() && $this->path !== false) {
            $this->setId();
            return;
        }

        if (false === $projectDir = \getenv('ASSETS_PROJECT_DIRECTORY')) {
            $projectDir = '';
        }
        $paths = [
            $this->path,
            $projectDir . $this->path
        ];

        foreach ($paths as $path) {
            if (false !== $this->path = realpath($path)) {

It seems like $path can also be of type boolean; however, parameter $path of realpath() does only seem to accept string, maybe add an additional type check?

                $this->setId();
                break;
            }
        }
    }

    private function checkIsUrl(): bool
    {
        if (\str_starts_with($this->path, '//')) {

It seems like $this->path can also be of type boolean; however, parameter $haystack of str_starts_with() does only seem to accept string, maybe add an additional type check?

            $this->path = Helpers::getHttpScheme() . ':' . $this->path;
            return true;
        }

        if (in_array(strpos($this->path, '://'), [4, 5])) {

It seems like $this->path can also be of type boolean; however, parameter $haystack of strpos() does only seem to accept string, maybe add an additional type check?

            return true;
        }
        return false;
    }



    public function isMinify(): bool
    {
        return $this->minify;
    }

    /**
     * @return false|string
     */
    public function getPath()
    {
        return $this->path;

The expression return $this->path also could return the type boolean which is incompatible with the documented return type false|string.

    }

    public function getType(): string
    {
        return $this->type;
    }

    public function isUrl(): bool
    {
        return $this->isUrl;
    }


    /**
     * @return string|null
     */
    public function getId(): ?string
    {
        return $this->id;
    }

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

    private function setId(): void
    {
        $this->id = md5($this->path);

It seems like $this->path can also be of type boolean; however, parameter $string of md5() does only seem to accept string, maybe add an additional type check?

    }
}