cms11/app/Console/Commands/Bundle/Render.php

<?php

namespace App\Console\Commands\Bundle;

use App\Classes\Bundle;
use Illuminate\Console\Command;
use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Support\Facades\Process;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

use function Laravel\Prompts\confirm;
use function Laravel\Prompts\progress;

class Render extends Command
{
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Render bundles';

    protected Filesystem $sourceDisk;

    protected Filesystem $targetDisk;

    public function __construct()
    {
        $this->signature = 'bundle:render 
            { --a|assets        : Rebuild assets - implies <info>-c</info> }
            { --c|clear-cache   : Clear cache before rendering }
            { --d|dry-run       : Show what would be done but do nothing }
            { --no-deploy       : Do not deploy, do not ask to deploy }
            { --r|recursive     : Also render sub-bundles } 
            { --source-disk=    : Use specified content disk - Defaults to <info>' . env('CONTENT_DISK') . '</info> }
            { --target-disk=    : Use specified rendering disk - Defaults to <info>' . env('DIST_DISK') . '</info> }
            { path?             : Path to a specific bundle to render - Default to <info>/</info> }
        ';

        parent::__construct();
    }

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $this->showDisclaimer()
            ->selectDisk()
            ->renderAssets()
            ->clearCache()
            ->render()
            ->deploy();
    }

    /**
     * Show a "disclaimer" for running dry-mode
     */
    private function showDisclaimer(): self
    {
        if (!$this->option('dry-run')) {
            return $this;
        }

        $this->newLine();
        $this->warn('Running dry-mode: no modification will be done');
        $this->newLine();

        return $this;
    }

    /**
     * Select the disk we will be working on
     */
    private function selectDisk(): self
    {
        $sourceDisk = $this->option('source-disk') ?? env('CONTENT_DISK');
        $targetDisk = $this->option('target-disk') ?? env('DIST_DISK');

        $this->sourceDisk = Storage::disk($sourceDisk);
        $this->targetDisk = Storage::disk($targetDisk);

        $this->line(
            sprintf(
                'Using <info>%s</info> as source disk and <info>%s</info> as target disk for generated content',
                $sourceDisk,
                $targetDisk
            )
        );

        return $this;
    }

    /**
     * Build assets, and clear cache afterwise
     */
    private function renderAssets(): self
    {
        // Do not re-generate assets if we didn't explicitely asked for it
        if (!$this->option('assets')) {
            return $this;
        }

        $this->output->write('Building assets... ');

        if (!$this->option('dry-run')) {
            Process::run('npm run build')->throw();
        }

        $this->info('OK');

        return $this;
    }

    /**
     * Clear application cache
     */
    private function clearCache(): self
    {
        // Do not clear cache if we didn't explicitely asked for it
        if (!$this->option('clear-cache') && !$this->option('assets')) {
            return $this;
        }

        // For now, we need to clear the cache, otherwise rendered HTML will
        // still reference old assets
        $this->output->write('Clearing cache... ');

        if (!$this->option('dry-run')) {
            $this->call('cache:clear', ['--quiet']);
        }

        $this->info('OK');

        return $this;
    }

    /**
     * Collect a list of bundles to render
     */
    private function getBundles()
    {
        $path    = $this->argument('path') ?? '/';
        $comment = sprintf('Rendering <info>%s</info>', $path);

        if ($this->option('recursive')) {
            $comment .= ' and <info>all sub-bundles</info>';
        }

        $this->line($comment);
        $this->output->write('Collecting bundles... ');

        if ($this->option('recursive')) {
            $bundles = Bundle::findBundles($this->sourceDisk, $path, true);
        } else {
            $bundles = [new Bundle($path, $this->sourceDisk)];
        }

        $this->info('OK');

        return $bundles;
    }

    /**
     * Perform rendering
     */
    private function render(): self
    {
        $bundles = $this->getBundles();

        progress(
            label: 'Rendering... ',
            steps: $bundles,
            callback: fn (Bundle $bundle, $progress) => $this->handleBundle($bundle, $progress)
        );

        return $this;
    }

    /**
     * Handle specific bundle
     */
    private function handleBundle(Bundle $bundle, $progress)
    {
        $progress->label(sprintf('Rendering %s ...', $bundle->getPath()));
        $progress->hint('Rendering the bundle');

        if ($this->option('dry-run')) {
            return;
        }

        $result = $bundle->render();

        foreach ($result as $path => $content) {
            if (!Str::contains($path, '.')) {
                $path = Str::finish($path, '/') . 'index.html';
            }

            $progress->hint(sprintf('Storing %s', $path));

            $this->targetDisk->put($path, $content);
        }
    }

    /**
     * Deploy to remote server
     */
    private function deploy()
    {
        // Do not even ask if --no-deploy was used
        if ($this->option('no-deploy')) {
            return;
        }

        // Ask for confirmation
        if (!confirm('Ready to deploy?')) {
            $this->comment('OK, not deploying!');

            return;
        }

        $source  = Str::finish($this->targetDisk->path('/'), '/');
        $target  = env('DEPLOY_TARGET');
        $command = __(env('DEPLOY_COMMAND'), [
            'source' => $source,
            'target' => $target,
        ]);

        $this->output->write(sprintf('Deploying using `%s` ... ', $command));

        if (!$this->option('dry-run')) {
            Process::run($command)->throw();
        }

        $this->info('OK');
    }
}