remove registry

src/Bridge/Nette/DI/ImageStorageExtension.php

@@ -32,17 +32,15 @@
 use Contributte\Imagist\LinkGeneratorInterface;
 use Contributte\Imagist\PathInfo\PathInfoFactory;
 use Contributte\Imagist\PathInfo\PathInfoFactoryInterface;
+use Contributte\Imagist\Persister\ChainImagePersister;
 use Contributte\Imagist\Persister\EmptyImagePersister;
 use Contributte\Imagist\Persister\PersistentImagePersister;
 use Contributte\Imagist\Persister\PersisterInterface;
-use Contributte\Imagist\Persister\PersisterRegistry;
-use Contributte\Imagist\Persister\PersisterRegistryInterface;
 use Contributte\Imagist\Persister\StorableImagePersister;
+use Contributte\Imagist\Remover\ChainImageRemover;
 use Contributte\Imagist\Remover\EmptyImageRemover;
 use Contributte\Imagist\Remover\PersistentImageRemover;
 use Contributte\Imagist\Remover\RemoverInterface;
-use Contributte\Imagist\Remover\RemoverRegistry;
-use Contributte\Imagist\Remover\RemoverRegistryInterface;
 use Contributte\Imagist\Resolver\BucketResolverInterface;
 use Contributte\Imagist\Resolver\BucketResolvers\BucketResolver;
 use Contributte\Imagist\Resolver\DefaultImageResolverInterface;
@@ -57,7 +55,6 @@
 use Doctrine\Common\Annotations\Reader;
 use Doctrine\DBAL\Driver\Connection;
 use Doctrine\ORM\EntityManagerInterface;
-use Imagine\Image\AbstractImagine;
 use Nette\Bridges\ApplicationLatte\ILatteFactory;
 use Nette\DI\CompilerExtension;
 use Nette\DI\ContainerBuilder;
@@ -74,9 +71,6 @@
 final class ImageStorageExtension extends CompilerExtension
 {
 
-	/** @var callable[] */
-	private array $onBeforeCompile = [];
-
 	public function getConfigSchema(): Schema
 	{
 		$builder = $this->getContainerBuilder();
@@ -97,9 +91,13 @@ public function getConfigSchema(): Schema
 					]),
 				]),
 				'imagine' => Expect::structure([
-					'enabled' => Expect::bool(class_exists(AbstractImagine::class)),
+					'enabled' => Expect::bool(false),
 				]),
 			]),
+			'registration' => Expect::structure([
+				'persisters' => Expect::bool(true),
+				'removers' => Expect::bool(true),
+			]),
 			'baseDir' => Expect::string($builder->parameters['wwwDir']),
 		]);
 	}
@@ -116,8 +114,14 @@ public function loadConfiguration(): void
 		$this->loadFile($builder);
 		$this->loadDatabase($builder);
 		$this->loadFilter($builder);
-		$this->loadPersister($builder);
-		$this->loadRemover($builder);
+
+		if ($config->registration->persisters) {
+			$this->loadPersister($builder);
+		}
+
+		if ($config->registration->removers) {
+			$this->loadRemover($builder);
+		}
 
 		if ($config->extensions->nette->filters->enabled) {
 			$this->loadNette($builder);
@@ -172,10 +176,6 @@ public function beforeCompile(): void
 			$this->assertServiceDefinition($builder->getDefinition($serviceName))
 				->addSetup('?::install(?);', [ImagistBlueScreen::class, '@self']);
 		}
-
-		foreach ($this->onBeforeCompile as $callback) {
-			$callback();
-		}
 	}
 
 	private function loadFilesystem(ContainerBuilder $builder): void
@@ -335,46 +335,41 @@ private function loadLatte(ContainerBuilder $builder): void
 
 	private function loadPersister(ContainerBuilder $builder): void
 	{
-		$persisterRegistry = $builder->addDefinition($this->prefix('persisterRegistry'))
-			->setType(PersisterRegistryInterface::class)
-			->setFactory(PersisterRegistry::class);
-
-		$this->onBeforeCompile[] = fn () => $this->foreach(
-			$builder->findByType(PersisterInterface::class),
-			fn (Definition $definition) => $persisterRegistry->addSetup('add', [$definition])
-		);
+		$chain[] = $builder->addDefinition($this->prefix('persisters.emptyImage'))
+			->setType(PersisterInterface::class)
+			->setFactory(EmptyImagePersister::class)
+			->setAutowired(false);
 
-		$builder->addDefinition($this->prefix('persisters.emptyImage'))
+		$chain[] = $builder->addDefinition($this->prefix('persisters.storableImage'))
 			->setType(PersisterInterface::class)
-			->setFactory(EmptyImagePersister::class);
+			->setFactory(StorableImagePersister::class)
+			->setAutowired(false);
 
-		$builder->addDefinition($this->prefix('persisters.storableImage'))
+		$chain[] = $builder->addDefinition($this->prefix('persisters.persistentImage'))
 			->setType(PersisterInterface::class)
-			->setFactory(StorableImagePersister::class);
+			->setFactory(PersistentImagePersister::class)
+			->setAutowired(false);
 
-		$builder->addDefinition($this->prefix('persisters.persistentImage'))
+		$builder->addDefinition($this->prefix('persisterRegistry'))
 			->setType(PersisterInterface::class)
-			->setFactory(PersistentImagePersister::class);
+			->setFactory(ChainImagePersister::class, [$chain]);
 	}
 
 	private function loadRemover(ContainerBuilder $builder): void
 	{
-		$removerRegistry = $builder->addDefinition($this->prefix('removerRegistry'))
-			->setType(RemoverRegistryInterface::class)
-			->setFactory(RemoverRegistry::class);
-
-		$this->onBeforeCompile[] = fn () => $this->foreach(
-			$builder->findByType(RemoverInterface::class),
-			fn (Definition $definition) => $removerRegistry->addSetup('add', [$definition])
-		);
+		$chain[] = $builder->addDefinition($this->prefix('removers.emptyImage'))
+			->setType(RemoverInterface::class)
+			->setFactory(EmptyImageRemover::class)
+			->setAutowired(false);
 
-		$builder->addDefinition($this->prefix('removers.emptyImage'))
+		$chain[] = $builder->addDefinition($this->prefix('removers.persisterImage'))
 			->setType(RemoverInterface::class)
-			->setFactory(EmptyImageRemover::class);
+			->setFactory(PersistentImageRemover::class)
+			->setAutowired(false);
 
-		$builder->addDefinition($this->prefix('removers.persisterImage'))
+		$builder->addDefinition($this->prefix('removerRegistry'))
 			->setType(RemoverInterface::class)
-			->setFactory(PersistentImageRemover::class);
+			->setFactory(ChainImageRemover::class, [$chain]);
 	}
 
 	private function loadNette(ContainerBuilder $builder): void

src/Persister/PersisterRegistry.php → src/Persister/ChainImagePersister.php

@@ -6,15 +6,23 @@
 use Contributte\Imagist\Exceptions\InvalidArgumentException;
 use Contributte\Imagist\Filter\Context\ContextInterface;
 
-final class PersisterRegistry implements PersisterRegistryInterface
+final class ChainImagePersister implements PersisterInterface
 {
 
 	/** @var PersisterInterface[] */
-	private array $persisters = [];
+	private array $persisters;
 
-	public function add(PersisterInterface $persister): void
+	/**
+	 * @param PersisterInterface[] $persisters
+	 */
+	public function __construct(array $persisters)
 	{
-		$this->persisters[] = $persister;
+		$this->persisters = $persisters;
+	}
+
+	public function supports(ImageInterface $image, ContextInterface $context): bool
+	{
+		return true;
 	}
 
 	public function persist(ImageInterface $image, ContextInterface $context): ImageInterface
@@ -25,7 +33,7 @@ public function persist(ImageInterface $image, ContextInterface $context): Image
 			}
 		}
 
-		throw new InvalidArgumentException(sprintf('Persist not found for class %s', get_class($image)));
+		throw new InvalidArgumentException(sprintf('Persister not found for class %s', get_class($image)));
 	}
 
 }

src/Persister/StorableImagePersister.php

@@ -8,6 +8,7 @@
 use Contributte\Imagist\Filter\Context\ContextInterface;
 use Contributte\Imagist\Filter\FilterProcessorInterface;
 use Contributte\Imagist\Resolver\FileNameResolverInterface;
+use Contributte\Imagist\Resolver\FilterResolvers\OriginalFilterResolver;
 
 final class StorableImagePersister extends ImagePersisterAbstract
 {
@@ -17,11 +18,12 @@ final class StorableImagePersister extends ImagePersisterAbstract
 	public function __construct(
 		FileFactoryInterface $fileFactory,
 		FilterProcessorInterface $filterProcessor,
-		FileNameResolverInterface $fileNameResolver
+		?FileNameResolverInterface $fileNameResolver = null
 	)
 	{
 		parent::__construct($fileFactory, $filterProcessor);
-		$this->fileNameResolver = $fileNameResolver;
+
+		$this->fileNameResolver = $fileNameResolver ?? new OriginalFilterResolver();
 	}
 
 	public function supports(ImageInterface $image, ContextInterface $context): bool

src/Remover/ChainImageRemover.php

@@ -0,0 +1,41 @@
+<?php declare(strict_types = 1);
+
+namespace Contributte\Imagist\Remover;
+
+use Contributte\Imagist\Entity\PersistentImageInterface;
+use Contributte\Imagist\Exceptions\InvalidArgumentException;
+use Contributte\Imagist\Filter\Context\ContextInterface;
+
+final class ChainImageRemover implements RemoverInterface
+{
+
+	/** @var RemoverInterface[] */
+	private array $removers;
+
+	/**
+	 * @param RemoverInterface[] $removers
+	 */
+	public function __construct(array $removers)
+	{
+		$this->removers = $removers;
+	}
+
+	public function supports(PersistentImageInterface $image, ContextInterface $context): bool
+	{
+		return true;
+	}
+
+	public function remove(PersistentImageInterface $image, ContextInterface $context): void
+	{
+		foreach ($this->removers as $remover) {
+			if ($remover->supports($image, $context)) {
+				$remover->remove($image, $context);
+
+				return;
+			}
+		}
+
+		throw new InvalidArgumentException(sprintf('Remover not found for class %s', get_class($image)));
+	}
+
+}

src/Remover/EmptyImageRemover.php

@@ -4,16 +4,17 @@
 
 use Contributte\Imagist\Entity\EmptyImageInterface;
 use Contributte\Imagist\Entity\PersistentImageInterface;
+use Contributte\Imagist\Filter\Context\ContextInterface;
 
 final class EmptyImageRemover implements RemoverInterface
 {
 
-	public function supports(PersistentImageInterface $image): bool
+	public function supports(PersistentImageInterface $image, ContextInterface $context): bool
 	{
 		return $image instanceof EmptyImageInterface;
 	}
 
-	public function remove(PersistentImageInterface $image): void
+	public function remove(PersistentImageInterface $image, ContextInterface $context): void
 	{
 		//throw new InvalidArgumentException('Cannot remove empty image');
 	}

src/Remover/PersistentImageRemover.php

@@ -6,6 +6,7 @@
 use Contributte\Imagist\Entity\PersistentImageInterface;
 use Contributte\Imagist\File\FileFactoryInterface;
 use Contributte\Imagist\Filesystem\FilesystemInterface;
+use Contributte\Imagist\Filter\Context\ContextInterface;
 use Contributte\Imagist\Filter\Internal\VoidFilter;
 use Contributte\Imagist\Filter\Operation\QualityOperation;
 use Contributte\Imagist\PathInfo\PathInfoFactoryInterface;
@@ -26,12 +27,12 @@ public function __construct(FileFactoryInterface $fileFactory, PathInfoFactoryIn
 		$this->filesystem = $filesystem;
 	}
 
-	public function supports(PersistentImageInterface $image): bool
+	public function supports(PersistentImageInterface $image, ContextInterface $context): bool
 	{
 		return !$image instanceof EmptyImageInterface;
 	}
 
-	public function remove(PersistentImageInterface $image): void
+	public function remove(PersistentImageInterface $image, ContextInterface $context): void
 	{
 		$this->removeOriginal($image);
 		$this->removeFiltered($image);

src/Remover/RemoverInterface.php

@@ -3,12 +3,13 @@
 namespace Contributte\Imagist\Remover;
 
 use Contributte\Imagist\Entity\PersistentImageInterface;
+use Contributte\Imagist\Filter\Context\ContextInterface;
 
 interface RemoverInterface
 {
 
-	public function supports(PersistentImageInterface $image): bool;
+	public function supports(PersistentImageInterface $image, ContextInterface $context): bool;
 
-	public function remove(PersistentImageInterface $image): void;
+	public function remove(PersistentImageInterface $image, ContextInterface $context): void;
 
 }