Merge 892159e into d160e24

Author: fredden

README.md

@@ -148,6 +148,23 @@ As an alternative to specifying the `--indent-size` and `--indent-style` options
 
 :bulb: The configuration provided in composer extra always overrides the configuration provided via command line options.
 
+#### Sorting of additional keys
+
+By default, this plug-in will sort all keys unless their order is important according to the Composer specification. This means that `repositories.*` and the children of `scripts.*.*` will remain in the order initially specified, but all other keys will be sorted. If you would like additional keys to remain unsorted, you may specify their paths in the `preserve-order` configuration option as follows:
+
+```json
+{
+  "extra": {
+    "composer-normalize": {
+      "preserve-order": [
+        "extra.installer-paths",
+        "extra.patches.*"
+      ]
+    }
+  }
+}
+```
+
 ### Continuous Integration
 
 If you want to run this in continuous integration services, use the `--dry-run` option.

composer.json

@@ -22,6 +22,8 @@
   },
   "require": {
     "php": "^8.0",
+    "ext-json": "*",
+    "ext-mbstring": "*",
     "composer-plugin-api": "^2.0.0",
     "ergebnis/json-normalizer": "~2.1.0",
     "ergebnis/json-printer": "^3.3.0",

composer.lock

@@ -29,6 +29,10 @@
  */
 final class NormalizeCommand extends Command\BaseCommand
 {
+    private const NEVER_SORT_PATHS = [
+        'scripts.*',
+    ];
+
     public function __construct(
         private Factory $factory,
         private Normalizer\NormalizerInterface $normalizer,
@@ -215,6 +219,8 @@ protected function execute(
             return 1;
         }
 
+        $normalized = self::restoreSortOrderForSpecificKeys($normalized, $json);
+
         $format = Normalizer\Format\Format::fromJson($json);
 
         if (null !== $indent) {
@@ -373,6 +379,10 @@ private static function indentFromExtra(array $extra): ?Normalizer\Format\Indent
             \array_keys($configuration),
         );
 
+        if ($missingKeys === $requiredKeys && isset($configuration['preserve-order'])) {
+            return null;
+        }
+
         if ([] !== $missingKeys) {
             throw new \RuntimeException(\sprintf(
                 'Configuration in composer extra requires keys "%s" with corresponding values."',
@@ -501,4 +511,69 @@ private static function updateLockerInWorkingDirectory(
             $output,
         );
     }
+
+    private static function restoreSortOrderForSpecificKeys(Normalizer\Json $normalized, Normalizer\Json $original): Normalizer\Json
+    {
+        $normalizedDecoded = (array) $normalized->decoded();
+        $originalDecoded = (array) $original->decoded();
+        $pathsToPreserve = self::NEVER_SORT_PATHS;
+
+        if (\count($originalDecoded) !== \count($normalizedDecoded)) {
+            // This is a workaround for a bug where $json->decoded() returns an empty object.
+            $originalDecoded = (array) Normalizer\Json::fromEncoded($original->encoded())->decoded();
+        }
+
+        if (isset($originalDecoded['extra'])) {
+            $extra = (array) $originalDecoded['extra'];
+
+            if (isset($extra['composer-normalize'])) {
+                $config = (array) $extra['composer-normalize'];
+
+                if (isset($config['preserve-order'])) {
+                    $userPaths = (array) $config['preserve-order'];
+                    $pathsToPreserve = \array_merge($pathsToPreserve, $userPaths);
+                }
+            }
+        }
+
+        foreach ($pathsToPreserve as $pathToPreserve) {
+            \assert(\is_string($pathToPreserve));
+            $normalizedDecoded = self::restoreSpecificKeyOrder($normalizedDecoded, $originalDecoded, $pathToPreserve);
+        }
+
+        return Normalizer\Json::fromEncoded(\json_encode($normalizedDecoded));
+    }
+
+    private static function restoreSpecificKeyOrder(array $normalized, array $original, string $path): array
+    {
+        if (\mb_strpos($path, '.') === false) {
+            // found a leaf
+            if (\array_key_exists($path, $normalized)) {
+                /** @var null|array|bool|float|int|object|string $original[$path] */
+                $normalized[$path] = $original[$path];
+            } elseif (\mb_strpos($path, '*') !== false) {
+                foreach (\array_keys($normalized) as $key) {
+                    if (\fnmatch($path, (string) $key)) {
+                        /** @var null|array|bool|float|int|object|string $original[$key] */
+                        $normalized[$key] = $original[$key];
+                    }
+                }
+            }
+        } else {
+            // found a branch
+            [$prefix, $suffix] = \explode('.', $path, 2);
+
+            if (\array_key_exists($prefix, $normalized)) {
+                $normalized[$prefix] = self::restoreSpecificKeyOrder((array) $normalized[$prefix], (array) $original[$prefix], $suffix);
+            } elseif (\mb_strpos($prefix, '*') !== false) {
+                foreach (\array_keys($normalized) as $key) {
+                    if (\fnmatch($prefix, (string) $key)) {
+                        $normalized[$key] = self::restoreSpecificKeyOrder((array) $normalized[$key], (array) $original[$key], $suffix);
+                    }
+                }
+            }
+        }
+
+        return $normalized;
+    }
 }

src/Command/NormalizeCommand.php

@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2018-2022 Andreas Möller
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE.md file that was distributed with this source code.
+ *
+ * @see https://github.com/ergebnis/composer-normalize
+ */
+
+namespace Ergebnis\Composer\Normalize\Test\Integration\Command\NormalizeCommand\Extra\Valid\WithPreserveOrder;
+
+use Ergebnis\Composer\Normalize\Test\Integration;
+use Ergebnis\Composer\Normalize\Test\Util;
+use Symfony\Component\Console;
+
+/**
+ * @internal
+ *
+ * @covers \Ergebnis\Composer\Normalize\Command\NormalizeCommand
+ * @covers \Ergebnis\Composer\Normalize\NormalizePlugin
+ *
+ * @uses \Ergebnis\Composer\Normalize\Version
+ */
+final class Test extends Integration\Command\NormalizeCommand\AbstractTestCase
+{
+    /**
+     * @dataProvider \Ergebnis\Composer\Normalize\Test\DataProvider\Command\NormalizeCommandProvider::commandInvocationIndentSizeAndIndentStyle
+     */
+    public function testSucceeds(
+        Util\CommandInvocation $commandInvocation,
+        int $indentSize,
+        string $indentStyle,
+    ): void {
+        $scenario = self::createScenario(
+            $commandInvocation,
+            __DIR__ . '/fixture',
+        );
+
+        $initialState = $scenario->initialState();
+
+        self::assertComposerJsonFileExists($initialState);
+        self::assertComposerLockFileNotExists($initialState);
+
+        $application = self::createApplicationWithNormalizeCommandAsProvidedByNormalizePlugin();
+
+        $input = new Console\Input\ArrayInput($scenario->consoleParameters());
+        $output = new Console\Output\BufferedOutput();
+
+        $exitCode = $application->run(
+            $input,
+            $output,
+        );
+
+        self::assertExitCodeSame(0, $exitCode);
+
+        $display = $output->fetch();
+
+        $expected = \sprintf(
+            'Successfully normalized %s.',
+            $scenario->composerJsonFileReference(),
+        );
+
+        self::assertStringContainsString($expected, $display);
+
+        $currentState = $scenario->currentState();
+
+        self::assertComposerJsonFileModified($initialState, $currentState);
+        self::assertComposerLockFileNotExists($currentState);
+
+        $decoded = (array) \json_decode($currentState->composerJsonFile()->contents(), true, 32, \JSON_THROW_ON_ERROR);
+        $require = (array) $decoded['require'];
+        self::assertSame(['ext-json', 'php'], \array_keys($require));
+        $extra = (array) $decoded['extra'];
+        self::assertSame(['composer-normalize', 'other'], \array_keys($extra));
+        $other = (array) $extra['other'];
+        self::assertSame(['keep-unsorted', 'sort-this'], \array_keys($other));
+        $keepUnsorted = (array) $other['keep-unsorted'];
+        self::assertSame(['one', 'two', 'three', 'four'], $keepUnsorted);
+
+        // FIXME: when ergebnis/json-normalizer has been upgraded to ^3.0, the following test can be uncommented / should work.
+        // @see https://github.com/ergebnis/composer-normalize/pull/956
+        // $sortThis = (array) $other['sort-this'];
+        // self::assertSame(['first', 'last'], $sortThis);
+    }
+}

test/Integration/Command/NormalizeCommand/Extra/Valid/WithPreserveOrder/Test.php

@@ -0,0 +1,40 @@
+{
+  "type": "library",
+  "_comment": "This composer.json is valid according to a lax validation, a composer.lock is not present, and composer.json is not yet normalized.",
+  "keywords": ["foo", "bar"],
+  "license": "MIT",
+  "authors": [
+    {"name": "Andreas Möller", "email": "[email protected]"}
+  ],
+  "extra": {
+    "other": {
+      "sort-this": [ "last", "first" ],
+      "keep-unsorted": [ "one", "two", "three", "four"]
+    },
+    "composer-normalize": {
+      "preserve-order": [
+        "this.path.does.*.not.*.exist.no-match-with-keys",
+        "require",
+        "extra.*.keep-unsorted"
+      ]
+    }
+  },
+  "require": {
+    "ext-json": "*",
+    "php": "^5.6"
+  },
+  "config": {
+    "allow-plugins": {
+      "ergebnis/composer-normalize": true,
+      "ergebnis/*": false
+    }
+  },
+  "scripts": {
+    "auto-scripts": {
+      "cache:clear": "symfony-cmd",
+      "doctrine:migrations:migrate -v": "symfony-cmd",
+      "bazinga:js-translation:dump assets --merge-domains --format=json": "symfony-cmd",
+      "assets:install %PUBLIC_DIR%": "symfony-cmd"
+    }
+  }
+}