[funding] Normalize composer sync output (#56)

Author: coisa

.github/FUNDING.yml

@@ -1,3 +1,3 @@
 github: php-fast-forward
 custom:
-  - https://www.paypal.com/donate/?business=JLDAF45XZ8D84
+  - 'https://www.paypal.com/donate/?business=JLDAF45XZ8D84'

README.md

@@ -123,7 +123,8 @@ metrics reports without extra setup.
 
 The `funding` command keeps supported `composer.json` funding entries aligned
 with `.github/FUNDING.yml`, including GitHub Sponsors handles and `custom`
-URLs, while preserving unsupported providers in place.
+URLs, while preserving unsupported providers in place and re-running
+`composer normalize` after manifest updates.
 
 The `skills` command keeps `.agents/skills` aligned with the packaged Fast
 Forward skill set. It creates missing links, repairs broken links, and

composer.json

@@ -26,6 +26,16 @@
         "source": "https://github.com/php-fast-forward/dev-tools",
         "docs": "https://php-fast-forward.github.io/dev-tools/"
     },
+    "funding": [
+        {
+            "type": "github",
+            "url": "https://github.com/sponsors/php-fast-forward"
+        },
+        {
+            "type": "custom",
+            "url": "https://www.paypal.com/donate/?business=JLDAF45XZ8D84"
+        }
+    ],
     "require": {
         "php": "^8.3",
         "composer-plugin-api": "^2.0",

docs/commands/funding.rst

@@ -97,6 +97,8 @@ Behavior
   entries.
 - Preserves unsupported Composer funding providers and unsupported GitHub
   funding YAML keys.
+- Normalizes ``composer.json`` with ``composer normalize`` after applying
+  funding metadata updates.
 - Creates ``.github/FUNDING.yml`` when Composer declares supported funding
   metadata and the file is missing.
 - Skips writing ``.github/FUNDING.yml`` when neither side declares supported

src/Console/Command/FundingCommand.php

@@ -25,6 +25,8 @@
 use FastForward\DevTools\Funding\ComposerFundingCodec;
 use FastForward\DevTools\Funding\FundingProfileMerger;
 use FastForward\DevTools\Funding\FundingYamlCodec;
+use FastForward\DevTools\Process\ProcessBuilderInterface;
+use FastForward\DevTools\Process\ProcessQueueInterface;
 use FastForward\DevTools\Resource\FileDiffer;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Input\InputInterface;
@@ -50,13 +52,17 @@ final class FundingCommand extends BaseCommand
      * @param FundingYamlCodec $fundingYamlCodec the codec used to parse and render GitHub funding YAML metadata
      * @param FundingProfileMerger $fundingProfileMerger the merger used to synchronize normalized funding profiles
      * @param FileDiffer $fileDiffer the differ used to summarize managed-file drift
+     * @param ProcessBuilderInterface $processBuilder the process builder used to normalize composer.json after updates
+     * @param ProcessQueueInterface $processQueue the process queue used to execute composer normalize
      */
     public function __construct(
         private readonly FilesystemInterface $filesystem,
         private readonly ComposerFundingCodec $composerFundingCodec,
         private readonly FundingYamlCodec $fundingYamlCodec,
         private readonly FundingProfileMerger $fundingProfileMerger,
         private readonly FileDiffer $fileDiffer,
+        private readonly ProcessBuilderInterface $processBuilder,
+        private readonly ProcessQueueInterface $processQueue,
     ) {
         parent::__construct();
     }
@@ -210,6 +216,11 @@ private function handleComposerFile(
         }
 
         $this->filesystem->dumpFile($composerFile, $updatedComposerContents);
+
+        if (self::SUCCESS !== $this->normalizeComposerFile($composerFile, $output)) {
+            return self::FAILURE;
+        }
+
         $output->writeln(\sprintf('<info>Updated funding metadata in %s.</info>', $composerFile));
 
         return self::SUCCESS;
@@ -296,4 +307,35 @@ private function shouldWriteManagedFile(InputInterface $input, OutputInterface $
 
         return (bool) $this->getHelper('question')->ask($input, $output, $question);
     }
+
+    /**
+     * Normalizes a composer manifest after funding metadata changes.
+     *
+     * @param string $composerFile the composer manifest path
+     * @param OutputInterface $output the command output
+     *
+     * @return int the normalization status code
+     */
+    private function normalizeComposerFile(string $composerFile, OutputInterface $output): int
+    {
+        $processBuilder = $this->processBuilder
+            ->withArgument('--ansi')
+            ->withArgument('--no-update-lock');
+
+        $workingDirectory = $this->filesystem->dirname($composerFile);
+
+        if ('.' !== $workingDirectory) {
+            $processBuilder = $processBuilder->withArgument('--working-dir', $workingDirectory);
+        }
+
+        $composerBasename = $this->filesystem->basename($composerFile);
+
+        if ('composer.json' !== $composerBasename) {
+            $processBuilder = $processBuilder->withArgument('--file', $composerBasename);
+        }
+
+        $this->processQueue->add($processBuilder->build('composer normalize'));
+
+        return $this->processQueue->run($output);
+    }
 }

src/Funding/ComposerFundingCodec.php

@@ -20,11 +20,10 @@
 namespace FastForward\DevTools\Funding;
 
 use Composer\Json\JsonFile;
-use Composer\Json\JsonManipulator;
-
 use function array_values;
 use function is_array;
 use function is_string;
+use function json_encode;
 use function parse_url;
 use function preg_match;
 use function sprintf;
@@ -103,7 +102,6 @@ public function parse(string $contents): FundingProfile
      */
     public function dump(string $contents, FundingProfile $profile): string
     {
-        $manipulator = new JsonManipulator($contents);
         $entries = [];
 
         foreach ($profile->getGithubSponsors() as $githubSponsor) {
@@ -124,13 +122,20 @@ public function dump(string $contents, FundingProfile $profile): string
             $entries[] = $unsupportedEntry;
         }
 
-        $manipulator->removeMainKey('funding');
+        $data = JsonFile::parseJson($contents);
+        unset($data['funding']);
 
-        if ([] !== $entries) {
-            $manipulator->addMainKey('funding', $entries);
+        if ([] === $entries) {
+            return json_encode(
+                $data,
+                JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE,
+            ) . "\n";
         }
 
-        return $manipulator->getContents();
+        return json_encode(
+            $this->insertFundingEntries($data, $entries),
+            JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE,
+        ) . "\n";
     }
 
     /**
@@ -159,4 +164,33 @@ private function extractGithubSponsor(string $url): ?string
 
         return $matches[1];
     }
+
+    /**
+     * Inserts funding entries in a stable Composer key order.
+     *
+     * @param array<string, mixed> $data the decoded composer.json payload
+     * @param array<int, array<string, mixed>> $entries the funding entries to insert
+     *
+     * @return array<string, mixed> the composer payload with funding inserted
+     */
+    private function insertFundingEntries(array $data, array $entries): array
+    {
+        $orderedData = [];
+        $inserted = false;
+
+        foreach ($data as $key => $value) {
+            $orderedData[$key] = $value;
+
+            if ('support' === $key) {
+                $orderedData['funding'] = $entries;
+                $inserted = true;
+            }
+        }
+
+        if (! $inserted) {
+            $orderedData['funding'] = $entries;
+        }
+
+        return $orderedData;
+    }
 }

src/Funding/FundingYamlCodec.php

@@ -81,7 +81,7 @@ public function dump(FundingProfile $profile): string
         }
 
         if ([] !== $profile->getCustomUrls()) {
-            $data['custom'] = $this->denormalizeList($profile->getCustomUrls());
+            $data['custom'] = $profile->getCustomUrls();
         }
 
         return Yaml::dump($data, 4, 2);

tests/Console/Command/FundingCommandTest.php

@@ -25,6 +25,8 @@
 use FastForward\DevTools\Funding\FundingProfile;
 use FastForward\DevTools\Funding\FundingProfileMerger;
 use FastForward\DevTools\Funding\FundingYamlCodec;
+use FastForward\DevTools\Process\ProcessBuilderInterface;
+use FastForward\DevTools\Process\ProcessQueueInterface;
 use FastForward\DevTools\Resource\FileDiff;
 use FastForward\DevTools\Resource\FileDiffer;
 use PHPUnit\Framework\Attributes\CoversClass;
@@ -37,6 +39,7 @@
 use ReflectionMethod;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Process\Process;
 use Symfony\Component\Yaml\Yaml;
 
 use function Safe\json_decode;
@@ -59,6 +62,12 @@ final class FundingCommandTest extends TestCase
 
     private ObjectProphecy $fileDiffer;
 
+    private ObjectProphecy $processBuilder;
+
+    private ObjectProphecy $processQueue;
+
+    private ObjectProphecy $normalizeProcess;
+
     private FundingCommand $command;
 
     protected function setUp(): void
@@ -67,6 +76,9 @@ protected function setUp(): void
         $this->input = $this->prophesize(InputInterface::class);
         $this->output = $this->prophesize(OutputInterface::class);
         $this->fileDiffer = $this->prophesize(FileDiffer::class);
+        $this->processBuilder = $this->prophesize(ProcessBuilderInterface::class);
+        $this->processQueue = $this->prophesize(ProcessQueueInterface::class);
+        $this->normalizeProcess = $this->prophesize(Process::class);
         $this->output->isDecorated()->willReturn(false);
         $this->output->writeln(Argument::any());
         $this->fileDiffer->formatForConsole(Argument::cetera())->willReturn(null);
@@ -76,13 +88,20 @@ protected function setUp(): void
         $this->input->getOption('check')->willReturn(false);
         $this->input->getOption('interactive')->willReturn(false);
         $this->filesystem->dirname('.github/FUNDING.yml')->willReturn('.github');
+        $this->filesystem->dirname('composer.json')->willReturn('.');
+        $this->filesystem->basename('composer.json')->willReturn('composer.json');
+        $this->processBuilder->withArgument(Argument::any())->willReturn($this->processBuilder->reveal());
+        $this->processBuilder->withArgument(Argument::any(), Argument::any())->willReturn($this->processBuilder->reveal());
+        $this->processBuilder->build('composer normalize')->willReturn($this->normalizeProcess->reveal());
 
         $this->command = new FundingCommand(
             $this->filesystem->reveal(),
             new ComposerFundingCodec(),
             new FundingYamlCodec(),
             new FundingProfileMerger(),
             $this->fileDiffer->reveal(),
+            $this->processBuilder->reveal(),
+            $this->processQueue->reveal(),
         );
     }
 
@@ -117,6 +136,8 @@ public function executeWillCreateComposerFundingFromFundingYaml(): void
             $fundingYaml,
             'Updating managed file .github/FUNDING.yml from generated funding metadata synchronization.',
         )->willReturn(new FileDiff(FileDiff::STATUS_UNCHANGED, 'Funding unchanged'))->shouldBeCalledOnce();
+        $this->processQueue->add($this->normalizeProcess->reveal())->shouldBeCalledOnce();
+        $this->processQueue->run($this->output->reveal())->willReturn(ProcessQueueInterface::SUCCESS)->shouldBeCalledOnce();
         $this->filesystem->dumpFile(
             'composer.json',
             Argument::that(static fn(string $contents): bool => str_contains($contents, '"funding"')),
@@ -149,7 +170,7 @@ public function executeWillCreateFundingYamlFromComposerFunding(): void
                 $decoded = Yaml::parse($contents);
 
                 return 'foo' === $decoded['github']
-                    && 'https://example.com/support' === $decoded['custom'];
+                    && ['https://example.com/support'] === $decoded['custom'];
             }),
             null,
             'Managed file .github/FUNDING.yml will be created from generated funding metadata synchronization.',
@@ -193,11 +214,13 @@ public function executeWillMergeBothSourcesWithoutDuplicatingEntries(): void
                 $decoded = Yaml::parse($contents);
 
                 return 'foo' === $decoded['github']
-                    && 'https://example.com/support' === $decoded['custom'];
+                    && ['https://example.com/support'] === $decoded['custom'];
             }),
             $fundingYaml,
             'Updating managed file .github/FUNDING.yml from generated funding metadata synchronization.',
         )->willReturn(new FileDiff(FileDiff::STATUS_CHANGED, 'Funding changed'))->shouldBeCalledOnce();
+        $this->processQueue->add($this->normalizeProcess->reveal())->shouldBeCalledOnce();
+        $this->processQueue->run($this->output->reveal())->willReturn(ProcessQueueInterface::SUCCESS)->shouldBeCalledOnce();
         $this->filesystem->dumpFile('composer.json', Argument::type('string'))->shouldBeCalledOnce();
         $this->filesystem->mkdir('.github')->shouldBeCalledOnce();
         $this->filesystem->dumpFile('.github/FUNDING.yml', Argument::type('string'))->shouldBeCalledOnce();
@@ -232,6 +255,7 @@ public function executeWillBeIdempotentWhenFundingMetadataAlreadyMatches(): void
             'Updating managed file .github/FUNDING.yml from generated funding metadata synchronization.',
         )->willReturn(new FileDiff(FileDiff::STATUS_UNCHANGED, 'Funding unchanged'))->shouldBeCalledOnce();
         $this->filesystem->dumpFile(Argument::cetera())->shouldNotBeCalled();
+        $this->processQueue->add(Argument::cetera())->shouldNotBeCalled();
 
         self::assertSame(FundingCommand::SUCCESS, $this->executeCommand());
     }

tests/Funding/FundingYamlCodecTest.php

@@ -68,4 +68,23 @@ public function dumpWillRenderScalarAndListFundingKeys(): void
             Yaml::parse($contents),
         );
     }
+
+    #[Test]
+    public function dumpWillRenderSingleCustomUrlAsList(): void
+    {
+        $codec = new FundingYamlCodec();
+
+        $contents = $codec->dump(new FundingProfile(
+            ['foo'],
+            ['https://example.com/support'],
+        ));
+
+        self::assertSame(
+            [
+                'github' => 'foo',
+                'custom' => ['https://example.com/support'],
+            ],
+            Yaml::parse($contents),
+        );
+    }
 }