Add featured image factory

packages/framework/src/Framework/Factories/FeaturedImageFactory.php

@@ -0,0 +1,138 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Factories;
+
+use Hyde\Framework\Concerns\InteractsWithFrontMatter;
+use Hyde\Framework\Features\Blogging\Models\FeaturedImage;
+use Hyde\Framework\Features\Blogging\Models\LocalFeaturedImage;
+use Hyde\Framework\Features\Blogging\Models\RemoteFeaturedImage;
+use Hyde\Hyde;
+use Hyde\Markdown\Contracts\FrontMatter\SubSchemas\FeaturedImageSchema;
+use Hyde\Markdown\Models\FrontMatter;
+use function is_string;
+use RuntimeException;
+use function str_starts_with;
+
+class FeaturedImageFactory extends Concerns\PageDataFactory implements FeaturedImageSchema
+{
+    use InteractsWithFrontMatter;
+
+    public const SCHEMA = FeaturedImageSchema::FEATURED_IMAGE_SCHEMA;
+
+    protected readonly string $source;
+    protected readonly ?string $altText;
+    protected readonly ?string $titleText;
+    protected readonly ?string $authorName;
+    protected readonly ?string $authorUrl;
+    protected readonly ?string $copyrightText;
+    protected readonly ?string $licenseName;
+    protected readonly ?string $licenseUrl;
+
+    public function __construct(
+        private readonly FrontMatter $matter,
+    ) {
+        $this->source = $this->makeSource();
+        $this->altText = $this->makeAltText();
+        $this->titleText = $this->makeTitleText();
+        $this->authorName = $this->makeAuthorName();
+        $this->authorUrl = $this->makeAuthorUrl();
+        $this->copyrightText = $this->makeCopyrightText();
+        $this->licenseName = $this->makeLicenseName();
+        $this->licenseUrl = $this->makeLicenseUrl();
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'source' => $this->source,
+            'altText' => $this->altText,
+            'titleText' => $this->titleText,
+            'authorName' => $this->authorName,
+            'authorUrl' => $this->authorUrl,
+            'copyrightText' => $this->copyrightText,
+            'licenseName' => $this->licenseName,
+            'licenseUrl' => $this->licenseUrl,
+        ];
+    }
+
+    public static function make(FrontMatter $matter): FeaturedImage
+    {
+        $data = (new static($matter))->toArray();
+
+        if (str_starts_with($data['source'], '_media')) {
+            return new LocalFeaturedImage(...$data);
+        }
+
+        return new RemoteFeaturedImage(...$data);
+    }
+
+    protected function makeSource(): string
+    {
+        if (is_string($this->matter('image'))) {
+            return $this->matter('image');
+        }
+
+        if ($this->matter('image.url') !== null) {
+            return $this->matter('image.url');
+        }
+
+        if ($this->matter('image.path') !== null) {
+            return $this->normalizeLocalImagePath($this->matter('image.path'));
+        }
+
+        // Todo, we might want to add a note about which file caused the error
+        throw new RuntimeException('No featured image source was found');
+    }
+
+    protected function makeAltText(): ?string
+    {
+        return $this->matter('image.description');
+    }
+
+    protected function makeTitleText(): ?string
+    {
+        return $this->matter('image.title');
+    }
+
+    protected function makeAuthorName(): ?string
+    {
+        return $this->matter('image.author');
+    }
+
+    protected function makeAuthorUrl(): ?string
+    {
+        return $this->matter('image.attributionUrl');
+    }
+
+    protected function makeCopyrightText(): ?string
+    {
+        return $this->matter('image.copyright');
+    }
+
+    protected function makeLicenseName(): ?string
+    {
+        return $this->matter('image.license');
+    }
+
+    protected function makeLicenseUrl(): ?string
+    {
+        return $this->matter('image.licenseUrl');
+    }
+
+    protected static function normalizeLocalImagePath(string $path): string
+    {
+        $path = Hyde::pathToRelative($path);
+
+        if (str_starts_with($path, '_media/')) {
+            return $path;
+        }
+
+        if (str_starts_with($path, 'media/')) {
+            return '_'.$path;
+        }
+
+        return '_media/'.$path;
+    }
+}

packages/framework/src/Framework/Features/Blogging/Models/RemoteFeaturedImage.php

@@ -8,7 +8,6 @@
 use function array_key_exists;
 use function config;
 use Illuminate\Support\Facades\Http;
-use InvalidArgumentException;
 use function key;
 
 class RemoteFeaturedImage extends FeaturedImage
@@ -17,10 +16,7 @@ class RemoteFeaturedImage extends FeaturedImage
 
     protected function setSource(string $source): void
     {
-        if (! str_starts_with($source, 'http')) {
-            // Throwing an exception here ensures we have a super predictable state.
-            throw new InvalidArgumentException('RemoteFeaturedImage source must be a valid URL');
-        }
+        // Here we can validate the source URL if we want.
 
         $this->source = $source;
     }

packages/framework/tests/Feature/FeaturedImageFactoryTest.php

@@ -0,0 +1,96 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Feature;
+
+use Hyde\Framework\Factories\FeaturedImageFactory;
+use Hyde\Framework\Features\Blogging\Models\LocalFeaturedImage;
+use Hyde\Framework\Features\Blogging\Models\RemoteFeaturedImage;
+use Hyde\Markdown\Models\FrontMatter;
+use Hyde\Testing\TestCase;
+use RuntimeException;
+
+/**
+ * @covers \Hyde\Framework\Factories\FeaturedImageFactory
+ */
+class FeaturedImageFactoryTest extends TestCase
+{
+    public function testWithDataFromSchema()
+    {
+        $array = [
+            'image.path' => 'path',
+            'image.url' => 'url',
+            'image.description' => 'description',
+            'image.title' => 'title',
+            'image.copyright' => 'copyright',
+            'image.license' => 'license',
+            'image.licenseUrl' => 'licenseUrl',
+            'image.author' => 'author',
+            'image.attributionUrl' => 'attributionUrl',
+        ];
+
+        $expected = [
+            'source' => 'url',
+            'altText' => 'description',
+            'titleText' => 'title',
+            'authorName' => 'author',
+            'authorUrl' => 'attributionUrl',
+            'copyrightText' => 'copyright',
+            'licenseName' => 'license',
+            'licenseUrl' => 'licenseUrl',
+        ];
+
+        $factory = new FeaturedImageFactory(new FrontMatter($array));
+
+        $this->assertSame($expected, $factory->toArray());
+    }
+
+    public function testMakeMethodCreatesLocalImageWhenPathIsSet()
+    {
+        $image = FeaturedImageFactory::make(new FrontMatter([
+            'image.path' => 'path',
+        ]));
+
+        $this->assertInstanceOf(LocalFeaturedImage::class, $image);
+        $this->assertSame('_media/path', $image->getSource());
+    }
+
+    public function testMakeMethodCreatesRemoteImageWhenUrlIsSet()
+    {
+        $image = FeaturedImageFactory::make(new FrontMatter([
+            'image.url' => 'url',
+        ]));
+
+        $this->assertInstanceOf(RemoteFeaturedImage::class, $image);
+        $this->assertSame('url', $image->getSource());
+    }
+
+    public function testMakeMethodCreatesRemoteImageWhenBothUrlAndPathIsSet()
+    {
+        $image = FeaturedImageFactory::make(new FrontMatter([
+            'image.url' => 'url',
+            'image.path' => 'path',
+        ]));
+
+        $this->assertInstanceOf(RemoteFeaturedImage::class, $image);
+        $this->assertSame('url', $image->getSource());
+    }
+
+    public function testMakeMethodThrowsExceptionIfNoPathInformationIsSet()
+    {
+        $this->expectException(RuntimeException::class);
+
+        FeaturedImageFactory::make(new FrontMatter([]));
+    }
+
+    public function testMakeMethodCanCreateImageFromJustString()
+    {
+        $image = FeaturedImageFactory::make(new FrontMatter([
+            'image' => 'foo',
+        ]));
+
+        $this->assertInstanceOf(RemoteFeaturedImage::class, $image);
+        $this->assertSame('foo', $image->getSource());
+    }
+}

packages/framework/tests/Feature/FeaturedImageTest.php

@@ -174,12 +174,10 @@ public function testCanConstructRemoteFeaturedImageWithHttps()
         $this->assertEquals('https/foo', $image->getSource());
     }
 
-    public function testCannotConstructRemoteFeaturedImageWithInvalidSource()
+    public function testCanConstructRemoteFeaturedImageWithInvalidSource()
     {
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('RemoteFeaturedImage source must be a valid URL');
-
-        new RemoteFeaturedImage('foo', ...$this->defaultArguments());
+        $image = new RemoteFeaturedImage('foo', ...$this->defaultArguments());
+        $this->assertEquals('foo', $image->getSource());
     }
 
     public function testFeaturedImageGetContentLengthWithRemoteSource()