feat(vite): add Vite installer (#901)

Author: innocenzi

src/Tempest/Console/src/Components/Renderers/InstructionsRenderer.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Components\Renderers;
+
+use Tempest\Support\StringHelper;
+use function Tempest\Support\arr;
+use function Tempest\Support\str;
+
+final class InstructionsRenderer
+{
+    private const int MAX_WIDTH = 175;
+
+    public function render(string|array $lines): string
+    {
+        $lines = arr($lines)
+            ->filter()
+            ->flatMap(fn (string $string) => str($string)->split(self::MAX_WIDTH)->toArray())
+            ->toArray();
+
+        $text = new StringHelper(PHP_EOL);
+
+        foreach ($lines as $line) {
+            $text = $text->append('  ', '<style="bold fg-green">│</style>', ' ', trim($line), PHP_EOL);
+        }
+
+        return $text->append(PHP_EOL)->toString();
+    }
+}

src/Tempest/Console/src/Console.php

@@ -74,6 +74,8 @@ public function success(string $lcontentsine, ?string $title = null): self;
 
     public function keyValue(string $key, ?string $value = null): self;
 
+    public function instructions(array|string $lines): self;
+
     /**
      * @param mixed|Closure(self): bool $condition
      * @param Closure(self): self $callback

src/Tempest/Console/src/GenericConsole.php

@@ -19,6 +19,7 @@
 use Tempest\Console\Components\Interactive\TaskComponent;
 use Tempest\Console\Components\Interactive\TextInputComponent;
 use Tempest\Console\Components\InteractiveComponentRenderer;
+use Tempest\Console\Components\Renderers\InstructionsRenderer;
 use Tempest\Console\Components\Renderers\KeyValueRenderer;
 use Tempest\Console\Components\Renderers\MessageRenderer;
 use Tempest\Console\Exceptions\UnsupportedComponent;
@@ -116,6 +117,13 @@ public function header(string $header, ?string $subheader = null): static
         return $this;
     }
 
+    public function instructions(array|string $lines): static
+    {
+        $this->writeln((new InstructionsRenderer())->render(ArrayHelper::wrap($lines)));
+
+        return $this;
+    }
+
     public function writeln(string $line = ''): static
     {
         $this->write($line . PHP_EOL);

src/Tempest/Core/src/Commands/InstallCommand.php

@@ -42,8 +42,6 @@ public function __invoke(?string $installer = null): void
         }
 
         $installer->install();
-
-        $this->success('Done.');
     }
 
     private function resolveInstaller(?string $search): ?Installer

src/Tempest/Core/src/PublishesFiles.php

@@ -5,6 +5,7 @@
 namespace Tempest\Core;
 
 use Closure;
+use Exception;
 use Tempest\Console\Exceptions\ConsoleException;
 use Tempest\Console\HasConsole;
 use Tempest\Container\Inject;
@@ -15,12 +16,18 @@
 use Tempest\Generation\Exceptions\FileGenerationAbortedException;
 use Tempest\Generation\Exceptions\FileGenerationFailedException;
 use Tempest\Generation\StubFileGenerator;
+use Tempest\Reflection\FunctionReflector;
 use Tempest\Support\NamespaceHelper;
+use Tempest\Support\StringHelper;
 use Tempest\Validation\Rules\EndsWith;
 use Tempest\Validation\Rules\NotEmpty;
 use Throwable;
+use function strlen;
 use function Tempest\path;
+use function Tempest\root_path;
 use function Tempest\Support\str;
+use const JSON_PRETTY_PRINT;
+use const JSON_UNESCAPED_SLASHES;
 
 /**
  * Provides a bunch of methods to publish and generate files and work with common user input.
@@ -45,14 +52,11 @@ trait PublishesFiles
      * @param string $destination The path to the destination file.
      * @param Closure(string $source, string $destination): void|null $callback A callback to run after the file is published.
      */
-    public function publish(
-        string $source,
-        string $destination,
-        ?Closure $callback = null,
-    ): void {
+    public function publish(string $source, string $destination, ?Closure $callback = null): string|false
+    {
         try {
             if (! $this->console->confirm(
-                question: sprintf('Do you want to create <em>%s</em>?', $destination),
+                question: sprintf('Do you want to create <file="%s" />?', $this->friendlyFileName($destination)),
                 default: true,
             )) {
                 throw new FileGenerationAbortedException('Skipped.');
@@ -96,7 +100,10 @@ public function publish(
             if ($callback !== null) {
                 $callback($source, $destination);
             }
+
+            return $destination;
         } catch (FileGenerationAbortedException) {
+            return false;
         } catch (Throwable $throwable) {
             if ($throwable instanceof ConsoleException) {
                 throw $throwable;
@@ -183,9 +190,86 @@ public function askForOverride(string $targetPath): bool
         }
 
         return $this->console->confirm(
-            question: sprintf('The file <em>%s</em> already exists. Do you want to override it?', $targetPath),
-            yes: 'Override',
-            no: 'Cancel',
+            question: sprintf('The file <file="%s" /> already exists. Do you want to override it?', $this->friendlyFileName($targetPath)),
         );
     }
+
+    /**
+     * Updates the contents of a file at the given path.
+     *
+     * @param string $path The absolute path to the file to update.
+     * @param Closure(string|StringHelper $contents): mixed $callback A callback that accepts the file contents and must return updated contents.
+     * @param bool $ignoreNonExisting Whether to throw an exception if the file does not exist.
+     */
+    public function update(string $path, Closure $callback, bool $ignoreNonExisting = false): void
+    {
+        if (! is_file($path)) {
+            if ($ignoreNonExisting) {
+                return;
+            }
+
+            throw new Exception("The file at path [{$path}] does not exist.");
+        }
+
+        $contents = file_get_contents($path);
+
+        $reflector = new FunctionReflector($callback);
+        $type = $reflector->getParameters()->current()->getType();
+
+        $contents = match (true) {
+            is_null($type),
+            $type->equals(StringHelper::class) => (string) $callback(new StringHelper($contents)),
+            $type->accepts('string') => (string) $callback($contents),
+            default => throw new Exception('The callback must accept a string or StringHelper.'),
+        };
+
+        file_put_contents($path, $contents);
+    }
+
+    /**
+     * Updates a JSON file, preserving indentation.
+     *
+     * @param string $path The absolute path to the file to update.
+     * @param Closure(array): array $callback
+     * @param bool $ignoreNonExisting Whether to throw an exception if the file does not exist.
+     */
+    public function updateJson(string $path, Closure $callback, bool $ignoreNonExisting = false): void
+    {
+        $this->update($path, function (string $content) use ($callback) {
+            $indent = $this->detectIndent($content);
+
+            $json = json_decode($content, associative: true);
+            $json = $callback($json);
+
+            // PHP will output empty arrays for empty dependencies,
+            // which is invalid and will make package managers crash.
+            foreach (['dependencies', 'devDependencies', 'peerDependencies'] as $key) {
+                if (isset($json[$key]) && empty($json[$key])) {
+                    unset($json[$key]);
+                }
+            }
+
+            $content = preg_replace_callback(
+                '/^ +/m',
+                fn ($m) => str_repeat($indent, strlen($m[0]) / 4),
+                json_encode($json, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES),
+            );
+
+            return "{$content}\n";
+        }, $ignoreNonExisting);
+    }
+
+    private function friendlyFileName(string $path): string
+    {
+        return str_replace(str(root_path())->finish('/')->toString(), '', $path);
+    }
+
+    private function detectIndent(string $raw): string
+    {
+        try {
+            return explode('"', explode("\n", $raw)[1])[0] ?: '';
+        } catch (Throwable) {
+            return '    ';
+        }
+    }
 }

src/Tempest/Support/src/JavaScript/DependencyInstaller.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Support\JavaScript;
+
+use Symfony\Component\Process\Process;
+use Tempest\Console\Console;
+use Tempest\Support\ArrayHelper;
+use Tempest\Validation\Rules\Enum;
+
+/**
+ * Helps with installing JavaScript dependencies in a directory.
+ */
+final class DependencyInstaller
+{
+    public function __construct(
+        private readonly Console $console,
+    ) {
+    }
+
+    /**
+     * Installs the specified JavaScript dependencies.
+     * The package manager will be detected from the lockfile present in `$cwd`. If none found, it will be prompted to the user.
+     */
+    public function installDependencies(string $cwd, string|array $dependencies, bool $dev = false): void
+    {
+        /** @var PackageManager */
+        $packageManager = PackageManager::detect($cwd) ?? $this->console->ask(
+            question: 'Which package manager do you wish to use?',
+            options: PackageManager::class,
+            default: PackageManager::BUN,
+            validation: [
+                new Enum(PackageManager::class),
+            ],
+        );
+
+        $process = new Process([
+            $packageManager->getBinaryName(),
+            $packageManager->getInstallCommand(),
+            $dev ? '-D' : '',
+            ...ArrayHelper::wrap($dependencies),
+        ], $cwd);
+
+        $this->console->task('Installing dependencies', $process);
+    }
+
+    /**
+     * Installs dependencies without interacting with the console.
+     */
+    public function silentlyInstallDependencies(string $cwd, string|array $dependencies, bool $dev = false, ?PackageManager $defaultPackageManager = null): void
+    {
+        $install = $this->getInstallProcess(
+            packageManager: PackageManager::detect($cwd) ?? $defaultPackageManager,
+            cwd: $cwd,
+            dependencies: $dependencies,
+            dev: $dev,
+        );
+
+        $install->mustRun();
+    }
+
+    /**
+     * Gets the `Process` instance that will install the specified dependencies.
+     */
+    private function getInstallProcess(PackageManager $packageManager, string $cwd, string|array $dependencies, bool $dev = false): Process
+    {
+        return new Process([
+            $packageManager->getBinaryName(),
+            $packageManager->getInstallCommand(),
+            $dev ? '-D' : '',
+            ...ArrayHelper::wrap($dependencies),
+        ], $cwd);
+    }
+}

src/Tempest/Support/src/JavaScript/PackageManager.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Support\JavaScript;
+
+/**
+ * Represents the major package managers in the JavaScript ecosystem.
+ * This enum is backed for serialization purposes.
+ */
+enum PackageManager: string
+{
+    case BUN = 'bun';
+    case PNPM = 'pnpm';
+    case YARN = 'yarn';
+    case NPM = 'npm';
+
+    public function getLockFiles(): array
+    {
+        return match ($this) {
+            self::BUN => ['bun.lock', 'bun.lockb'],
+            self::NPM => ['package-lock.json'],
+            self::YARN => ['yarn.lock'],
+            self::PNPM => ['pnpm-lock.yaml'],
+        };
+    }
+
+    public function getBinaryName(): string
+    {
+        return match ($this) {
+            self::BUN => 'bun',
+            self::NPM => 'npm',
+            self::YARN => 'yarn',
+            self::PNPM => 'pnpm',
+        };
+    }
+
+    public function getInstallCommand(): string
+    {
+        return match ($this) {
+            self::BUN => 'install',
+            self::NPM => 'install',
+            self::YARN => '',
+            self::PNPM => 'install',
+        };
+    }
+
+    public static function detect(string $cwd): ?self
+    {
+        foreach (PackageManager::cases() as $packageManager) {
+            foreach ($packageManager->getLockFiles() as $lockFile) {
+                if (file_exists($cwd . '/' . $lockFile)) {
+                    return $packageManager;
+                }
+            }
+        }
+
+        return null;
+    }
+}