Add command to generate static files

Author: jdecool

.env

@@ -14,6 +14,7 @@
 # https://symfony.com/doc/current/best_practices.html#use-environment-variables-for-infrastructure-configuration
 
 DATABASE_DSN=sqlite:/src/var/db.sqlite
+FILESYSTEM_ROOT=var/output
 
 ###> symfony/framework-bundle ###
 APP_ENV=dev

config/services.yaml

@@ -2,15 +2,30 @@ services:
     _defaults:
         autowire: true
         autoconfigure: true
+        bind:
+            string $outputFolder: '%env(FILESYSTEM_ROOT)%'
 
     App\:
         resource: '../src/'
         exclude:
+            - '../src/Command/SynchronizeCommand.php'
             - '../src/DependencyInjection/'
             - '../src/Entity/'
             - '../src/Kernel.php'
             - '../src/Tests/'
 
+    App\Command\SynchronizeCommand.db:
+        class: App\Command\SynchronizeCommand
+        arguments:
+            $storage: '@App\Storage\PDOStorage'
+            $name: 'synchronize:database'
+
+    App\Command\SynchronizeCommand.fs:
+        class: App\Command\SynchronizeCommand
+        arguments:
+            $storage: '@App\Storage\FilesystemStorage'
+            $name: 'synchronize:files'
+
     App\Controller\:
         resource: '../src/Controller/'
         tags: ['controller.service_arguments']

src/Command/SynchronizeCommand.php

@@ -7,9 +7,7 @@
 use App\{
     Clock,
     PhpVersionFetcher,
-    Repository\PDO\LastUpdateRepository,
-    Repository\PDO\PdoPhpReleaseRepository,
-    Repository\PDO\PdoPhpVersionRepository,
+    Storage,
 };
 use Symfony\Component\Console\{
     Command\Command,
@@ -21,33 +19,39 @@ final class SynchronizeCommand extends Command
 {
     public function __construct(
         private Clock $clock,
-        private LastUpdateRepository $lastUpdateRepository,
-        private PdoPhpReleaseRepository $releaseRepository,
-        private PdoPhpVersionRepository $versionRepository,
         private PhpVersionFetcher $fetcher,
+        private Storage $storage,
+        string $name
     ) {
-        parent::__construct('synchronize');
+        parent::__construct($name);
     }
 
     protected function execute(InputInterface $input, OutputInterface $output): int
     {
-        $currentTime = $this->clock->now()->format('Y-m-d H:i:s');
-        $output->writeln("<info>[$currentTime] Process current versions</info>");
-        $currents = $this->fetcher->currents();
-        $this->versionRepository->save(...$currents);
+        $versions = [];
 
-        $currentTime = $this->clock->now()->format('Y-m-d H:i:s');
-        $output->writeln("<info>[$currentTime] Process unmaintened versions</info>");
-        $eol = $this->fetcher->eol();
-        $this->versionRepository->save(...$eol);
+        $this->log($output, 'Fetch current versions');
+        foreach ($this->fetcher->currents() as $version) {
+            $versions[] = $version;
+        }
 
-        $currentTime = $this->clock->now()->format('Y-m-d H:i:s');
-        $output->writeln("<info>[$currentTime] Process releases versions</info>");
+        $this->log($output, 'Fetch unmaintened versions');
+        foreach ($this->fetcher->eol() as $version) {
+            $versions[] = $version;
+        }
+
+        $this->log($output, 'Fetch releases versions');
         $releases = $this->fetcher->releases();
-        $this->releaseRepository->save(...$releases);
 
-        $this->lastUpdateRepository->save();
+        $this->log($output, 'Write data');
+        $this->storage->write($versions, $releases);
 
         return 0;
     }
+
+    private function log(OutputInterface $output, string $text): void
+    {
+        $currentTime = $this->clock->now()->format('Y-m-d H:i:s');
+        $output->writeln("<info>[$currentTime] $text</info>");
+    }
 }

src/Model/Collection.php

@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Model;
+
+use JDecool\Collection\Collection as BaseCollection;
+
+/**
+ * @template TKey
+ * @template TValue
+ */
+class Collection
+{
+    public static function createEmpty(): self
+    {
+        return new self();
+    }
+
+    public static function fromIterable(iterable $data): self
+    {
+        $arr = [];
+        foreach ($data as $key => $value) {
+            $arr[$key] = $value;
+        }
+
+        return new self($arr);
+    }
+
+    private function __construct(
+        private array $data = [],
+    ) {
+    }
+
+    /**
+     * @param TKey $key
+     * @param TValue $value
+     */
+    public function add($key, $value): void
+    {
+        $this->data[$key] = $value;
+    }
+}

src/Storage.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App;
+
+interface Storage
+{
+    public function write(iterable $versions, iterable $releases): void;
+}

src/Storage/FilesystemStorage.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Storage;
+
+use App\Clock;
+use App\Model\PhpVersion;
+use App\Storage;
+use JDecool\Collection\Collection;
+use RuntimeException;
+use Symfony\Component\Serializer\SerializerInterface;
+
+final class FilesystemStorage implements Storage
+{
+    public function __construct(
+        private Clock $clock,
+        private SerializerInterface $serializer,
+        private string $outputFolder = '',
+    ) {
+        if (trim($this->outputFolder) === '') {
+            $this->outputFolder = getcwd();
+        }
+    }
+
+    public function write(iterable $versions, iterable $releases): void
+    {
+        $this->writeAllVersionsFile($versions);
+        $this->writeMaintenedVersions($versions);
+        $this->writeUnmaintenedVersions($versions);
+        $this->writeReleaseVersions($releases);
+    }
+
+    private function writeAllVersionsFile(iterable $versions): void
+    {
+        $this->writeFile('all.json', $versions);
+    }
+
+    /**
+     * @param iterable<PhpVersion> $versions
+     */
+    private function writeMaintenedVersions(iterable $versions): void
+    {
+        $data = (new Collection($versions))->filter(
+            fn (PhpVersion $version): bool => $version->getEndOfLife() > $this->clock->now(),
+        );
+
+        $this->writeFile('maintened.json', $data);
+    }
+
+    private function writeUnmaintenedVersions(iterable $versions): void
+    {
+        $data = (new Collection($versions))->filter(
+            fn (PhpVersion $version): bool => $version->getEndOfLife() <= $this->clock->now(),
+        );
+
+        $this->writeFile('unmaintened.json', $data);
+    }
+
+    private function writeReleaseVersions(iterable $releases): void
+    {
+        $this->writeFile('releases.json', $releases);
+    }
+
+    private function writeFile(string $path, iterable $data): void
+    {
+        $fullpath = rtrim($this->outputFolder, DIRECTORY_SEPARATOR).'/'.ltrim($path, DIRECTORY_SEPARATOR);
+
+        $basedir = dirname($fullpath);
+        if (!file_exists($basedir)) {
+            @mkdir($basedir, 0777, true);
+        }
+
+        if (false === file_put_contents($fullpath, ['items' => $this->serializer->serialize($data, 'json')])) {
+            throw new RuntimeException("An error occured while writing file.");
+        }
+    }
+}

src/Storage/PDOStorage.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Storage;
+
+use App\Model\PhpRelease;
+use App\Model\PhpVersion;
+use App\Repository\PDO\LastUpdateRepository;
+use App\Repository\PDO\PdoPhpReleaseRepository;
+use App\Repository\PDO\PdoPhpVersionRepository;
+use App\Storage;
+
+final class PDOStorage implements Storage
+{
+    public function __construct(
+        private LastUpdateRepository $lastUpdateRepository,
+        private PdoPhpReleaseRepository $releaseRepository,
+        private PdoPhpVersionRepository $versionRepository
+    ) {
+    }
+
+    /**
+     * @param iterable<PhpVersion> $versions
+     * @param iterable<PhpRelease> $releases
+     */
+    public function write(iterable $versions, iterable $releases): void
+    {
+        $this->versionRepository->save(...$versions);
+        $this->releaseRepository->save(...$releases);
+
+        $this->lastUpdateRepository->save();
+    }
+}