Add AssetMapper support

.github/workflows/phpstan.yml

@@ -26,5 +26,9 @@ jobs:
       - name: Add vips
         run: composer require rokka/imagine-vips
 
+      - name: Add asset mapper
+        if: ${{ matrix.php-version >= '8.0' || (matrix.php-version == '' && 8.2 >= 8.0) }}
+        run: composer require symfony/asset-mapper
+
       - name: Run PHPStan
         run: vendor/bin/phpstan analyze

.github/workflows/phpunit.yml

@@ -84,6 +84,10 @@ jobs:
           SYMFONY_DEPRECATIONS_HELPER: max[self]=0
         run: vendor/bin/simple-phpunit -v
 
+      - name: Add asset mapper
+        if: ${{ matrix.symfony >= '6.4' }}
+        run: composer require --no-update symfony/asset-mapper --dev
+
       - name: Install php-coveralls
         run: composer global require --no-interaction --no-progress php-coveralls/php-coveralls
 

Binary/Locator/AssetMapperLocator.php

@@ -0,0 +1,85 @@
+<?php
+
+/*
+ * This file is part of the `liip/LiipImagineBundle` project.
+ *
+ * (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
+ *
+ * For the full copyright and license information, please view the LICENSE.md
+ * file that was distributed with this source code.
+ */
+
+namespace Liip\ImagineBundle\Binary\Locator;
+
+use Liip\ImagineBundle\Exception\Binary\Loader\NotLoadableException;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\AssetMapper\AssetMapperInterface;
+
+/**
+ * Class responsible for locating assets in the asset mapper.
+ * Implements the LocatorInterface to resolve asset paths.
+ * This Class should be used only in dev environment.
+ */
+class AssetMapperLocator implements LocatorInterface
+{
+    private $assetMapper;
+    private $cacheMapCache;
+
+    public function __construct(
+        AssetMapperInterface $assetMapper,
+        ?CacheItemPoolInterface $cacheMapCache = null
+    ) {
+        $this->cacheMapCache = $cacheMapCache;
+        $this->assetMapper = $assetMapper;
+    }
+
+    /**
+     * Locates an asset by its public path.
+     *
+     * This method attempts to retrieve an asset using its public path. It first
+     * checks for a cached version of the asset, and if none is found, it iterates
+     * through all available assets to find a match. If no matching asset is located,
+     * an exception is thrown.
+     *
+     * Inspired by Symfony's AssetMapper component @see https://github.com/symfony/asset-mapper/blob/7.3/AssetMapperDevServerSubscriber.php#L179.
+     *
+     * @param string $path the public path of the asset to locate
+     *
+     * @throws NotLoadableException if no asset with the specified public path is found
+     *
+     * @return string the located asset
+     */
+    public function locate(string $path): string
+    {
+        $pathInfo = '/'.ltrim($path, '/');
+        $cachedAsset = null;
+        if (null !== $this->cacheMapCache) {
+            $cachedAsset = $this->cacheMapCache->getItem(hash('xxh128', $pathInfo));
+            $asset = $cachedAsset->isHit() ? $this->assetMapper->getAsset($cachedAsset->get()) : null;
+
+            if (null !== $asset && $asset->publicPath === $pathInfo) {
+                return $asset->sourcePath;
+            }
+        }
+
+        // we did not find a match
+        $asset = null;
+        foreach ($this->assetMapper->allAssets() as $assetCandidate) {
+            if ($pathInfo === $assetCandidate->publicPath) {
+                $asset = $assetCandidate;
+                break;
+            }
+        }
+
+        if (null === $asset) {
+            throw new NotLoadableException(\sprintf('Asset with public path "%s" not found.', $pathInfo));
+        }
+
+        if (null !== $cachedAsset) {
+            $cachedAsset->set($asset->logicalPath);
+            $this->cacheMapCache->save($cachedAsset);
+        }
+
+        return $asset->sourcePath;
+    }
+}

DependencyInjection/Factory/Loader/AssetMapperLoaderFactory.php

@@ -0,0 +1,50 @@
+<?php
+
+/*
+ * This file is part of the `liip/LiipImagineBundle` project.
+ *
+ * (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
+ *
+ * For the full copyright and license information, please view the LICENSE.md
+ * file that was distributed with this source code.
+ */
+
+namespace Liip\ImagineBundle\DependencyInjection\Factory\Loader;
+
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+class AssetMapperLoaderFactory extends AbstractLoaderFactory
+{
+    public function create(ContainerBuilder $container, $loaderName, array $config)
+    {
+        $locatorDefinition = new ChildDefinition('liip_imagine.binary.locator.asset_mapper');
+        $locatorDefinition->replaceArgument(0, new Reference('asset_mapper'));
+        $locatorDefinition->replaceArgument(1, new Reference('cache.asset_mapper'));
+
+        $definition = $this->getChildLoaderDefinition('filesystem');
+
+        if ($container->hasDefinition('liip_imagine.mime_types')) {
+            $mimeTypes = $container->getDefinition('liip_imagine.mime_types');
+            $definition->replaceArgument(0, $mimeTypes);
+            $definition->replaceArgument(1, $mimeTypes);
+        }
+        $definition->replaceArgument(2, $locatorDefinition);
+
+        return $this->setTaggedLoaderDefinition($loaderName, $definition, $container);
+    }
+
+    public function getName()
+    {
+        return 'asset_mapper';
+    }
+
+    public function addConfiguration(ArrayNodeDefinition $builder)
+    {
+        $builder
+            ->children()
+            ->end();
+    }
+}

LiipImagineBundle.php

@@ -23,6 +23,7 @@
 use Liip\ImagineBundle\DependencyInjection\Compiler\NonFunctionalFilterExceptionPass;
 use Liip\ImagineBundle\DependencyInjection\Compiler\PostProcessorsCompilerPass;
 use Liip\ImagineBundle\DependencyInjection\Compiler\ResolversCompilerPass;
+use Liip\ImagineBundle\DependencyInjection\Factory\Loader\AssetMapperLoaderFactory;
 use Liip\ImagineBundle\DependencyInjection\Factory\Loader\ChainLoaderFactory;
 use Liip\ImagineBundle\DependencyInjection\Factory\Loader\FileSystemLoaderFactory;
 use Liip\ImagineBundle\DependencyInjection\Factory\Loader\FlysystemLoaderFactory;
@@ -69,6 +70,7 @@ public function build(ContainerBuilder $container): void
         $extension->addLoaderFactory(new StreamLoaderFactory());
         $extension->addLoaderFactory(new FileSystemLoaderFactory());
         $extension->addLoaderFactory(new FlysystemLoaderFactory());
+        $extension->addLoaderFactory(new AssetMapperLoaderFactory());
         $extension->addLoaderFactory(new ChainLoaderFactory());
 
         $container->registerForAutoconfiguration(LoaderLoaderInterface::class)->addTag('liip_imagine.filter.loader');

Resources/config/imagine.php

@@ -21,6 +21,7 @@
 use Liip\ImagineBundle\Binary\Loader\FlysystemLoader;
 use Liip\ImagineBundle\Binary\Loader\FlysystemV2Loader;
 use Liip\ImagineBundle\Binary\Loader\StreamLoader;
+use Liip\ImagineBundle\Binary\Locator\AssetMapperLocator;
 use Liip\ImagineBundle\Binary\Locator\FileSystemInsecureLocator;
 use Liip\ImagineBundle\Binary\Locator\FileSystemLocator;
 use Liip\ImagineBundle\Binary\SimpleMimeTypeGuesser;
@@ -429,6 +430,14 @@
             '', // will be injected by FilesystemLoaderFactory
         ])
         ->tag('liip_imagine.binary.locator', ['shared' => false]);
+    $services->set('liip_imagine.binary.locator.asset_mapper', AssetMapperLocator::class)
+        ->share(true)
+        ->public()
+        ->args([
+            '', // will be injected by AssetMapperLoaderFactory
+            '', // will be injected by AssetMapperLoaderFactory
+        ])
+        ->tag('liip_imagine.binary.locator', ['shared' => false]);
 
     $services->set('liip_imagine.binary.locator.filesystem_insecure', FileSystemInsecureLocator::class)
         ->share(false)

Resources/doc/configuration.rst

@@ -77,7 +77,8 @@ There are several configuration options available:
 * ``cache`` - default cache resolver. Default value: ``web_path`` (which means
   the standard web_path resolver is used)
 * ``data_loader`` - name of a custom data loader. Default value: ``filesystem``
-  (which means the standard filesystem loader is used).
+  (which means the standard filesystem loader is used). Built-in loaders include:
+  ``filesystem``, ``chain``, ``flysystem``, ``stream``, and ``asset_mapper``.
 * ``twig.mode`` - Twig filter integration. ``none`` disables the twig filters, ``lazy`` enables
   Twig using the Twig runtime for lazy loading. The default value is ``legacy`` and enables the
   old Twig integration that is loaded on each request. Version 3 will drop ``legacy`` and default
@@ -99,7 +100,8 @@ There are several configuration options available:
     * ``cache`` - default cache resolver. Default value: ``web_path`` (which means
       the standard web_path resolver is used)
     * ``data_loader`` - name of a custom data loader. Default value: ``filesystem``
-      (which means the standard filesystem loader is used).
+      (which means the standard filesystem loader is used). Built-in loaders include:
+      ``filesystem``, ``chain``, ``flysystem``, ``stream``, and ``asset_mapper``.
     * ``post_processors`` - sets post-processors to be applied on filtered image
       (see Post-Processors section in the :doc:`filters chapter <filters>` for details).
 * ``driver`` - one of the drivers: ``gd``, ``imagick``, ``gmagick``, ``vips``.

Resources/doc/data-loader/asset_mapper.rst

@@ -0,0 +1,29 @@
+
+.. _data-loaders-asset-mapper:
+
+Asset Mapper Loader (for dev)
+============================
+
+The ``AssetMapper`` data loader allows for loading images using Symfony's AssetMapper component.
+
+Configuration
+-------------
+
+To enable the Asset Mapper loader, you need to configure it in your loaders section. 
+A common use case is to use it in combination with the default filesystem loader using a chain loader, 
+especially in development environment.
+
+.. code-block:: yaml
+
+    # config/packages/liip_imagine.yaml
+    when@dev:
+        liip_imagine:
+            loaders:
+                asset_mapper:
+                    asset_mapper: ~
+                chain:
+                    chain:
+                        loaders: [ asset_mapper, default ]
+            data_loader: chain
+
+This configuration creates an ``asset_mapper`` loader and a ``chain`` loader that first tries to find the asset via AssetMapper, and then falls back to the ``default`` loader. Finally, it sets the global ``data_loader`` to use this new ``chain`` loader.

Tests/Binary/Locator/AssetMapperLocatorTest.php

@@ -0,0 +1,151 @@
+<?php
+
+/*
+ * This file is part of the `liip/LiipImagineBundle` project.
+ *
+ * (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
+ *
+ * For the full copyright and license information, please view the LICENSE.md
+ * file that was distributed with this source code.
+ */
+
+namespace Liip\ImagineBundle\Tests\Binary\Locator;
+
+use Liip\ImagineBundle\Binary\Locator\AssetMapperLocator;
+use Liip\ImagineBundle\Binary\Locator\LocatorInterface;
+use Liip\ImagineBundle\Exception\Binary\Loader\NotLoadableException;
+use PHPUnit\Framework\TestCase;
+use Psr\Cache\CacheItemInterface;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\AssetMapper\AssetMapperInterface;
+use Symfony\Component\AssetMapper\MappedAsset;
+
+/**
+ * @covers \Liip\ImagineBundle\Binary\Locator\AssetMapperLocator
+ */
+class AssetMapperLocatorTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        if (!interface_exists(AssetMapperInterface::class)) {
+            $this->markTestSkipped('symfony/asset-mapper is required for this test.');
+        }
+    }
+
+    public function testImplementsLocatorInterface(): void
+    {
+        $assetMapper = $this->createMock(AssetMapperInterface::class);
+        $this->assertInstanceOf(LocatorInterface::class, new AssetMapperLocator($assetMapper));
+    }
+
+    public function testLocateWithoutCache(): void
+    {
+        $path = 'images/logo.png';
+        $pathInfo = '/images/logo.png';
+        $sourcePath = '/path/to/logo.png';
+        $logicalPath = 'logo.png';
+
+        $asset = new MappedAsset($logicalPath, $sourcePath, $pathInfo, $pathInfo);
+
+        $assetMapper = $this->createMock(AssetMapperInterface::class);
+        $assetMapper->expects($this->once())
+            ->method('allAssets')
+            ->willReturn([$asset]);
+
+        $locator = new AssetMapperLocator($assetMapper);
+        $result = $locator->locate($path);
+
+        $this->assertSame($sourcePath, $result);
+    }
+
+    public function testLocateWithCacheHit(): void
+    {
+        $path = 'images/logo.png';
+        $pathInfo = '/images/logo.png';
+        $logicalPath = 'logo.png';
+        $sourcePath = '/path/to/logo.png';
+
+        $asset = new MappedAsset($logicalPath, $sourcePath, $pathInfo, $pathInfo);
+
+        $cacheItem = $this->createMock(CacheItemInterface::class);
+        $cacheItem->expects($this->once())
+            ->method('isHit')
+            ->willReturn(true);
+        $cacheItem->expects($this->once())
+            ->method('get')
+            ->willReturn($logicalPath);
+
+        $cache = $this->createMock(CacheItemPoolInterface::class);
+        $cache->expects($this->once())
+            ->method('getItem')
+            ->with(hash('xxh128', $pathInfo))
+            ->willReturn($cacheItem);
+
+        $assetMapper = $this->createMock(AssetMapperInterface::class);
+        $assetMapper->expects($this->once())
+            ->method('getAsset')
+            ->with($logicalPath)
+            ->willReturn($asset);
+        $assetMapper->expects($this->never())
+            ->method('allAssets');
+
+        $locator = new AssetMapperLocator($assetMapper, $cache);
+        $result = $locator->locate($path);
+
+        $this->assertSame($sourcePath, $result);
+    }
+
+    public function testLocateWithCacheMissAndSave(): void
+    {
+        $path = 'images/logo.png';
+        $pathInfo = '/images/logo.png';
+        $logicalPath = 'logo.png';
+        $sourcePath = '/path/to/logo.png';
+
+        $asset = new MappedAsset($logicalPath, $sourcePath, $pathInfo, $pathInfo);
+
+        $cacheItem = $this->createMock(CacheItemInterface::class);
+        $cacheItem->expects($this->once())
+            ->method('isHit')
+            ->willReturn(false);
+        $cacheItem->expects($this->once())
+            ->method('set')
+            ->with($logicalPath);
+
+        $cache = $this->createMock(CacheItemPoolInterface::class);
+        $cache->expects($this->once())
+            ->method('getItem')
+            ->with(hash('xxh128', $pathInfo))
+            ->willReturn($cacheItem);
+        $cache->expects($this->once())
+            ->method('save')
+            ->with($cacheItem);
+
+        $assetMapper = $this->createMock(AssetMapperInterface::class);
+        $assetMapper->expects($this->once())
+            ->method('allAssets')
+            ->willReturn([$asset]);
+
+        $locator = new AssetMapperLocator($assetMapper, $cache);
+        $result = $locator->locate($path);
+
+        $this->assertSame($sourcePath, $result);
+    }
+
+    public function testThrowsIfAssetNotFound(): void
+    {
+        $path = 'images/logo.png';
+
+        $assetMapper = $this->createMock(AssetMapperInterface::class);
+        $assetMapper->expects($this->once())
+            ->method('allAssets')
+            ->willReturn([]);
+
+        $locator = new AssetMapperLocator($assetMapper);
+
+        $this->expectException(NotLoadableException::class);
+        $this->expectExceptionMessage('Asset with public path "/images/logo.png" not found.');
+
+        $locator->locate($path);
+    }
+}