Hyde\Framework\Features\Blogging\Models\FeaturedImage

Complexity

Total Complexity

35

Size/Duplication

Total Lines	218
Duplicated Lines	0 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	3	1
A	getSource()	0	8	2
A	getType()	0	3	1
A	getContentLength()	0	7	2
A	setSource()	0	8	2
A	__construct()	0	13	2
A	has()	0	3	1
A	getContentLengthForLocalImage()	0	3	1
A	getCaption()	0	3	1
A	getMetadataArray()	0	20	4
A	getLicenseName()	0	3	1
A	getTitleText()	0	3	1
A	hasAuthorUrl()	0	3	1
A	getAltText()	0	3	1
A	hasAltText()	0	3	1
A	getContentLengthForRemoteImage()	0	17	3
A	hasAuthorName()	0	3	1
A	hasTitleText()	0	3	1
A	hasCaption()	0	3	1
A	hasLicenseUrl()	0	3	1
A	hasLicenseName()	0	3	1
A	getAuthorUrl()	0	3	1
A	getLicenseUrl()	0	3	1
A	getAuthorName()	0	3	1
A	hasCopyrightText()	0	3	1
A	getCopyrightText()	0	3	1

<?php

declare(strict_types=1);

namespace Hyde\Framework\Features\Blogging\Models;

use Hyde\Hyde;
use Stringable;
use Hyde\Facades\Config;
use Illuminate\Support\Str;
use Hyde\Support\BuildWarnings;
use Illuminate\Support\Facades\Http;
use Hyde\Foundation\Kernel\Hyperlinks;
use Hyde\Support\Filesystem\MediaFile;
use Hyde\Markdown\Contracts\FrontMatter\SubSchemas\FeaturedImageSchema;

use function array_key_exists;
use function array_flip;
use function key;

/**
 * Object representation of a blog post's featured image.
 *
 * While the object can of course be used for any other page type,
 * it is named "FeaturedImage" as it's only usage within Hyde
 * is for the featured image of a Markdown blog post.
 *
 * @see \Hyde\Framework\Factories\FeaturedImageFactory
 */
class FeaturedImage implements Stringable, FeaturedImageSchema
{
    /**
     * A featured image object, for a file stored locally.
     *
     * The internal data structure forces the image source to reference a file in the _media directory,
     * and thus that is what is required for the input. However, when outputting data, the data will
     * be used for the _site/media directory, so it will provide data relative to the site root.
     *
     * The source information is stored in $this->source, which is a file in the _media directory.
     */
    protected final const TYPE_LOCAL = 'local';

    /**
     * A featured image object, for a file stored remotely.
     */
    protected final const TYPE_REMOTE = 'remote';

    /** @var self::TYPE_* */
    protected readonly string $type;

    protected readonly string $source;

    public function __construct(
        string $source,
        protected readonly ?string $altText = null,
        protected readonly ?string $titleText = null,
        protected readonly ?string $authorName = null,
        protected readonly ?string $authorUrl = null,
        protected readonly ?string $licenseName = null,
        protected readonly ?string $licenseUrl = null,
        protected readonly ?string $copyrightText = null,
        protected readonly ?string $caption = null
    ) {
        $this->type = Hyperlinks::isRemote($source) ? self::TYPE_REMOTE : self::TYPE_LOCAL;

The property type is declared read-only in Hyde\Framework\Features\Blogging\Models\FeaturedImage.

It seems like Hyde\Foundation\Kernel\Hyperlinks::isRemote($source) ? self::TYPE_REMOTE : self::TYPE_LOCAL of type string is incompatible with the declared type Hyde\Framework\Features\Blogging\Models\FeaturedImage of property $type.

        $this->source = $this->setSource($source);

The property source is declared read-only in Hyde\Framework\Features\Blogging\Models\FeaturedImage.

    }

    public function __toString(): string
    {
        return $this->getSource();
    }

    /**
     * Get the source of the image, must be usable within the src attribute of an image tag,
     * and is thus not necessarily the path to the source image on disk.
     *
     * @return string The image's url or path
     */
    public function getSource(): string
    {
        if ($this->type === self::TYPE_LOCAL) {
            // Return value is always resolvable from a compiled page in the _site directory.
            return (string) Hyde::asset($this->source);

The method asset() does not exist on Hyde\Hyde. Since you implemented __callStatic, consider adding a @method annotation.

        }

        return $this->source;
    }

    protected function setSource(string $source): string
    {
        if ($this->type === self::TYPE_LOCAL) {
            // Normalize away any leading media path prefixes.
            return Str::after($source, Hyde::getMediaDirectory().'/');

The method getMediaDirectory() does not exist on Hyde\Hyde. Since you implemented __callStatic, consider adding a @method annotation.

        }

        return $source;
    }

    public function getContentLength(): int
    {
        if ($this->type === self::TYPE_LOCAL) {
            return $this->getContentLengthForLocalImage();
        }

        return $this->getContentLengthForRemoteImage();
    }

    /** @return self::TYPE_* */
    public function getType(): string
    {
        return $this->type;

The expression return $this->type returns the type string which is incompatible with the documented return type Hyde\Framework\Features\Blogging\Models\FeaturedImage.

    }

    /**
     * Used in resources/views/components/post/image.blade.php to add meta tags with itemprop attributes.
     *
     * @return array{text?: string|null, name?: string|null, url: string, contentUrl: string}
     */
    public function getMetadataArray(): array
    {
        $metadata = [];

        if ($this->hasAltText()) {
            $metadata['text'] = $this->getAltText();
        }

        if ($this->hasTitleText()) {
            $metadata['name'] = $this->getTitleText();
        }

        if ($this->hasCaption()) {
            $metadata['caption'] = $this->getCaption();
        }

        $metadata['url'] = $this->getSource();
        $metadata['contentUrl'] = $this->getSource();

        return $metadata;
    }

    public function getAltText(): ?string
    {
        return $this->altText ?? $this->caption;
    }

    public function getTitleText(): ?string
    {
        return $this->titleText;
    }

    public function getAuthorName(): ?string
    {
        return $this->authorName;
    }

    public function getAuthorUrl(): ?string
    {
        return $this->authorUrl;
    }

    public function getCopyrightText(): ?string
    {
        return $this->copyrightText;
    }

    public function getLicenseName(): ?string
    {
        return $this->licenseName;
    }

    public function getLicenseUrl(): ?string
    {
        return $this->licenseUrl;
    }

    public function getCaption(): ?string
    {
        return $this->caption;
    }

    public function hasAltText(): bool
    {
        return $this->has('altText');
    }

    public function hasTitleText(): bool
    {
        return $this->has('titleText');
    }

    public function hasAuthorName(): bool
    {
        return $this->has('authorName');
    }

    public function hasAuthorUrl(): bool
    {
        return $this->has('authorUrl');
    }

    public function hasCopyrightText(): bool
    {
        return $this->has('copyrightText');
    }

    public function hasLicenseName(): bool
    {
        return $this->has('licenseName');
    }

    public function hasLicenseUrl(): bool
    {
        return $this->has('licenseUrl');
    }

    public function hasCaption(): bool
    {
        return $this->has('caption');
    }

    protected function has(string $property): bool
    {
        return $this->$property !== null;
    }

    protected function getContentLengthForLocalImage(): int
    {
        return MediaFile::get($this->source)->getLength();
    }

    protected function getContentLengthForRemoteImage(): int
    {
        // API calls can be skipped in the config, or by setting the --no-api flag when running the build command.
        if (Config::getBool('hyde.api_calls', true)) {
            /** @var string[][] $headers */
            $headers = Http::withHeaders([
                'User-Agent' => Config::getString('hyde.http_user_agent', 'RSS Request Client'),
            ])->head($this->getSource())->headers();

            if (array_key_exists('Content-Length', $headers)) {
                return (int) key(array_flip($headers['Content-Length']));
            }

            BuildWarnings::report('The image "'.$this->getSource().'" has a content length of zero.');
        }

        return 0;
    }
}