IBX-2663: Implemented --no-hash option in normalize-paths command

eZ/Bundle/EzPublishCoreBundle/Command/NormalizeImagesPathsCommand.php

@@ -18,6 +18,7 @@
 use eZ\Publish\Core\IO\Values\MissingBinaryFile;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Style\SymfonyStyle;
 
@@ -34,6 +35,8 @@ final class NormalizeImagesPathsCommand extends Command
 - Manually clear SPI/HTTP cache after running this command.
 EOT;
 
+    private const SKIP_HASHING_COMMAND_PARAMETER = 'no-hash';
+
     protected static $defaultName = 'ibexa:images:normalize-paths';
 
     /** @var \eZ\Publish\Core\FieldType\Image\ImageStorage\Gateway */
@@ -48,6 +51,9 @@ final class NormalizeImagesPathsCommand extends Command
     /** @var \eZ\Publish\Core\IO\IOServiceInterface */
     private $ioService;
 
+    /** @var bool */
+    private $skipHashing;
+
     public function __construct(
         ImageStorageGateway $imageGateway,
         FilePathNormalizerInterface $filePathNormalizer,
@@ -68,6 +74,12 @@ protected function configure()
 
         $this
             ->setDescription('Normalizes stored paths for images.')
+            ->addOption(
+                self::SKIP_HASHING_COMMAND_PARAMETER,
+                null,
+                InputOption::VALUE_NONE,
+                'Skip filename hashing'
+            )
             ->setHelp(
                 <<<EOT
 The command <info>%command.name%</info> normalizes paths for images.
@@ -80,13 +92,19 @@ protected function configure()
     protected function execute(InputInterface $input, OutputInterface $output): int
     {
         $io = new SymfonyStyle($input, $output);
+
         $io->title('Normalize image paths');
 
         $io->writeln([
             'Determining the number of images that require path normalization.',
             'It may take some time.',
         ]);
 
+        $this->skipHashing = $input->getOption(self::SKIP_HASHING_COMMAND_PARAMETER);
+        $this->skipHashing
+            ? $io->caution('Image filenames will not be hashed.')
+            : $io->caution('Image filenames will be hashed with format {hash}-{sanitized name}.');
+
         $imagePathsToNormalize = $this->getImagePathsToNormalize($io);
 
         $imagePathsToNormalizeCount = \count($imagePathsToNormalize);
@@ -222,7 +240,7 @@ static function (array $data) use ($filePath) {
 
         return !empty($processedPaths)
             ? $processedPaths[0]['newPath']
-            : $this->filePathNormalizer->normalizePath($filePath);
+            : $this->filePathNormalizer->normalizePath($filePath, !$this->skipHashing);
     }
 
     private function getImagePathsToNormalize(SymfonyStyle $io): array

eZ/Publish/Core/IO/FilePathNormalizer/Flysystem.php

@@ -24,14 +24,16 @@ public function __construct(SlugConverter $slugConverter)
         $this->slugConverter = $slugConverter;
     }
 
-    public function normalizePath(string $filePath): string
+    public function normalizePath(string $filePath, bool $doHash = true): string
     {
         $fileName = pathinfo($filePath, PATHINFO_BASENAME);
         $directory = pathinfo($filePath, PATHINFO_DIRNAME);
 
-        $fileName = $this->slugConverter->convert($fileName);
+        $fileName = $this->slugConverter->convert($fileName, '_1', 'urlalias');
 
-        $hash = preg_match(self::HASH_PATTERN, $fileName) ? '' : bin2hex(random_bytes(6)) . '-';
+        $hash = $doHash
+            ? (preg_match(self::HASH_PATTERN, $fileName) ? '' : bin2hex(random_bytes(6)) . '-')
+            : '';
 
         $filePath = $directory . \DIRECTORY_SEPARATOR . $hash . $fileName;
 

eZ/Publish/Core/IO/FilePathNormalizerInterface.php

@@ -13,5 +13,5 @@
  */
 interface FilePathNormalizerInterface
 {
-    public function normalizePath(string $filePath): string;
+    public function normalizePath(string $filePath, bool $doHash = true): string;
 }

eZ/Publish/Core/IO/Tests/FilePathNormalizer/FlysystemTest.php

@@ -33,15 +33,16 @@ public function testNormalizePath(
         string $originalPath,
         string $fileName,
         string $sluggedFileName,
-        string $regex
+        string $regex,
+        bool $doHash
     ): void {
         $this->slugConverter
             ->expects(self::once())
             ->method('convert')
             ->with($fileName)
             ->willReturn($sluggedFileName);
 
-        $normalizedPath = $this->filePathNormalizer->normalizePath($originalPath);
+        $normalizedPath = $this->filePathNormalizer->normalizePath($originalPath, $doHash);
 
         self::assertStringEndsWith($sluggedFileName, $normalizedPath);
         self::assertRegExp($regex, $normalizedPath);
@@ -57,30 +58,56 @@ public function providerForTestNormalizePath(): array
                 'image.jpg',
                 'image.jpg',
                 $defaultPattern . 'image.jpg/',
+                true,
             ],
             'Spaces in the filename' => [
                 '4/3/2/234/1/image with spaces.jpg',
                 'image with spaces.jpg',
                 'image-with-spaces.jpg',
                 $defaultPattern . 'image-with-spaces.jpg/',
+                true,
             ],
             'Encoded spaces in the name' => [
                 '4/3/2/234/1/image%20+no+spaces.jpg',
                 'image%20+no+spaces.jpg',
                 'image-20-nospaces.jpg',
                 $defaultPattern . 'image-20-nospaces.jpg/',
+                true,
             ],
             'Special chars in the name' => [
                 '4/3/2/234/1/image%20+no+spaces?.jpg',
                 'image%20+no+spaces?.jpg',
                 'image-20-nospaces.jpg',
                 $defaultPattern . 'image-20-nospaces.jpg/',
+                true,
             ],
             'Already hashed name' => [
                 '4/3/2/234/1/14ff44718877-hashed.jpg',
                 '14ff44718877-hashed.jpg',
                 '14ff44718877-hashed.jpg',
                 '/^4\/3\/2\/234\/1\/14ff44718877-hashed.jpg$/',
+                true,
+            ],
+            'No special chars and no hashing' => [
+                '4/3/2/234/1/image.jpg',
+                'image.jpg',
+                'image.jpg',
+                '/\/image.jpg/',
+                false,
+            ],
+            'Special chars and no hashing' => [
+                '4/3/2/234/1/image%20+no+spaces.jpg',
+                'image%20+no+spaces.jpg',
+                'image-20-nospaces.jpg',
+                '/\/image-20-nospaces.jpg/',
+                false,
+            ],
+            'Already hashed name and no hashing' => [
+                '4/3/2/234/1/14ff44718877-hashed.jpg',
+                '14ff44718877-hashed.jpg',
+                '14ff44718877-hashed.jpg',
+                '/^4\/3\/2\/234\/1\/14ff44718877-hashed.jpg$/',
+                false,
             ],
         ];
     }