ServeCommand::safeHandle() - Code Metrics - Inspection of "Merge pull request #2299 from hydephp/fix/Improve-..." - hydephp/develop - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ced3fe...73fb21 )

by Caen
created 2025-09-27 17:58 UTC
ServeCommand::safeHandle() A

↳ Parent: ServeCommand
Complexity

Conditions	4
Paths	8
Size

Total Lines	26
Code Lines	14
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	4
eloc	14
nc	8
nop	0
dl	0
loc	26
rs	9.7998
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace Hyde\RealtimeCompiler\Console\Commands;

use Closure;
use Hyde\Facades\Filesystem;
use Hyde\Hyde;
use Hyde\Facades\Config;
use Illuminate\Contracts\Process\InvokedProcess;
use Illuminate\Support\Arr;
use Illuminate\Support\Sleep;
use InvalidArgumentException;
use Exception;
use Hyde\Console\Concerns\Command;
use Hyde\RealtimeCompiler\ConsoleOutput;
use Illuminate\Support\Facades\Process;

use function rtrim;
use function sprintf;
use function in_array;
use function str_replace;
use function class_exists;

/**
 * Start the realtime compiler server.
 *
 * @see https://github.com/hydephp/realtime-compiler
 */
class ServeCommand extends Command
{
    /** @var string */
    protected $signature = 'serve
        {--host= : <comment>[default: "localhost"]</comment>}}
        {--port= : <comment>[default: 8080]</comment>}
        {--save-preview= : Should the served page be saved to disk? (Overrides config setting)}
        {--dashboard= : Enable the realtime compiler dashboard. (Overrides config setting)}
        {--pretty-urls= : Enable pretty URLs. (Overrides config setting)}
        {--play-cdn= : Enable the Tailwind Play CDN. (Overrides config setting)}
        {--open=false : Open the site preview in the browser.}
        {--vite : Enable Vite for Hot Module Replacement (HMR)}
    ';

    /** @var string */
    protected $description = 'Start the realtime compiler server';

    protected ConsoleOutput $console;

    protected InvokedProcess $server;
    protected ?InvokedProcess $vite = null;

    public function safeHandle(): int
    {
        $this->configureOutput();
        $this->printStartMessage();

        if ($this->option('open') !== 'false') {
            $this->openInBrowser((string) $this->option('open'));
        }

        if ($this->option('vite')) {
            $this->runViteProcess();
        }

        $this->runServerProcess(sprintf('php -S %s:%d %s',
            $this->getHostSelection(),
            $this->getPortSelection(),
            escapeshellarg($this->getExecutablePath()),
        ));

        $this->handleRunningProcesses();

        if ($this->option('vite')) {
            $this->cleanupViteHotFile();
        }

        return Command::SUCCESS;
    }

    protected function getHostSelection(): string
    {
        return (string) $this->option('host') ?: Config::getString('hyde.server.host', 'localhost');
    }

    protected function getPortSelection(): int
    {
        return (int) ($this->option('port') ?: Config::getInt('hyde.server.port', 8080));
    }

    protected function getExecutablePath(): string
    {
        return Hyde::path('vendor/hyde/realtime-compiler/bin/server.php');
        return Hyde::/** @scrutinizer ignore-call */ path('vendor/hyde/realtime-compiler/bin/server.php');
    }

    protected function runServerProcess(string $command): void
    {
        $this->server = Process::forever()->env($this->getEnvironmentVariables())->start($command, $this->getOutputHandler());
    }

    protected function getEnvironmentVariables(): array
    {
        return Arr::whereNotNull([
            'HYDE_SERVER_REQUEST_OUTPUT' => ! $this->option('no-ansi'),
            'HYDE_SERVER_SAVE_PREVIEW' => $this->parseEnvironmentOption('save-preview'),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            'HYDE_SERVER_DASHBOARD' => $this->parseEnvironmentOption('dashboard'),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            'HYDE_PRETTY_URLS' => $this->parseEnvironmentOption('pretty-urls'),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            'HYDE_PLAY_CDN' => $this->parseEnvironmentOption('play-cdn'),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        ]);
    }

    protected function configureOutput(): void
    {
        if (! $this->useBasicOutput()) {
            $this->console = new ConsoleOutput($this->output->isVerbose());
        }
    }

    protected function printStartMessage(): void
    {
        $this->useBasicOutput()
            ? $this->output->writeln('<info>Starting the HydeRC server...</info> Use Ctrl+C to stop')
            : $this->console->printStartMessage($this->getHostSelection(), $this->getPortSelection(), $this->getEnvironmentVariables(), $this->option('vite'));
            : $this->console->printStartMessage($this->getHostSelection(), $this->getPortSelection(), $this->getEnvironmentVariables(), /** @scrutinizer ignore-type */ $this->option('vite'));
    }

    protected function getOutputHandler(): Closure
    {
        return $this->useBasicOutput() ? function (string $type, string $line): void {
            $this->output->write($line);
        } : $this->console->getFormatter();
    }

    protected function useBasicOutput(): bool
    {
        return $this->option('no-ansi') || ! class_exists(ConsoleOutput::class);
    }

    protected function parseEnvironmentOption(string $name): ?string
    {
        $value = $this->option($name) ?? $this->checkArgvForOption($name);

        if ($value !== null) {
            return match ($value) {
                'true', '' => 'enabled',
                'false' => 'disabled',
                default => throw new InvalidArgumentException(sprintf('Invalid boolean value for --%s option.', $name))
            };
        }

        return null;
    }

    /** Fallback check so that an environment option without a value is acknowledged as true. */
    protected function checkArgvForOption(string $name): ?string
    {
        if (isset($_SERVER['argv'])) {
            if (in_array("--$name", $_SERVER['argv'], true)) {
                return 'true';
            }
        }

        return null;
    }

    protected function openInBrowser(string $path = '/'): void
    {
        $binary = $this->getOpenCommand(PHP_OS_FAMILY);

        $command = sprintf('%s http://%s:%d', $binary, $this->getHostSelection(), $this->getPortSelection());
        $command = rtrim("$command/$path", '/');

        $process = $binary ? Process::command($command)->run() : null;

        if (! $process || $process->failed()) {
            $this->warn('Unable to open the site preview in the browser on your system:');
            $this->line(sprintf('  %s', str_replace("\n", "\n  ", $process ? $process->errorOutput() : "Missing suitable 'open' binary.")));
            $this->newLine();
        }
    }

    protected function getOpenCommand(string $osFamily): ?string
    {
        return match ($osFamily) {
            'Windows' => 'start',
            'Darwin' => 'open',
            'Linux' => 'xdg-open',
            default => null
        };
    }

    protected function runViteProcess(): void
    {
        if (! $this->isPortAvailable(5173)) {
            throw new InvalidArgumentException(
                'Unable to start Vite server: Port 5173 is already in use. '.
                'Please stop any other Vite processes and try again.'
            );
        }

        $this->ensureNodeModulesAvailable();

        Filesystem::touch('app/storage/framework/runtime/vite.hot');

        try {
            $this->vite = Process::forever()->start('npm run dev');
        } catch (Exception $exception) {
            throw new InvalidArgumentException(
                'Unable to start Vite server: '.$exception->getMessage()
            );
        }
    }

    protected function handleRunningProcesses(): void
    {
        while ($this->server->running()) {
            $this->handleViteOutput();

            Sleep::for(100)->milliseconds();
        }
    }

    protected function handleViteOutput(): void
    {
        if ($this->vite?->running()) {
            $output = $this->vite->latestOutput();
            $output = $this->vite->latestOutput();

            if ($output) {
                $this->output->write($output);
            }
        }
    }

    /** @experimental This feature may be removed before the final release. */
    protected function isPortAvailable(int $port): bool
    {
        $addresses = ['localhost', '127.0.0.1'];

        foreach ($addresses as $address) {
            $socket = @fsockopen($address, $port, $errno, $errstr, 1);
            if ($socket !== false) {
                fclose($socket);

                return false;
            }
        }

        return true;
    }

    protected function cleanupViteHotFile(): void
    {
        $hotFile = 'app/storage/framework/runtime/vite.hot';

        if (Filesystem::exists($hotFile)) {
            Filesystem::unlinkIfExists($hotFile);
        }
    }

    protected function ensureNodeModulesAvailable(): void
    {
        if (! $this->nodeModulesInstalled()) {
            if ($this->input->isInteractive()) {
                $this->warn('Node modules are not installed. Vite requires Node dependencies to function.');

                if ($this->confirm('Would you like to install them now?', true)) {
                    $this->installNodeModules();
                } else {
                    throw new InvalidArgumentException(
                        'The --vite flag cannot be used if Vite is not installed. Please run "npm install" first.'
                    );
                }
            } else {
                throw new InvalidArgumentException(
                    'Node modules are not installed. The --vite flag cannot be used if Vite is not installed. Please run "npm install" first.'
                );
            }
        }
    }

    protected function nodeModulesInstalled(): bool
    {
        return Filesystem::exists(Hyde::path('node_modules'))
            && Filesystem::exists(Hyde::path('package.json'));
    }

    protected function installNodeModules(): void
    {
        $this->info('Installing Node modules...');

        $process = Process::run('npm install');

        if ($process->failed()) {
            throw new InvalidArgumentException(
                'Failed to install Node modules: '.$process->errorOutput()
            );
        }

        $this->info('Node modules installed successfully.');

        if (! $this->nodeModulesInstalled()) {
            throw new InvalidArgumentException(
                'Node modules installation completed but dependencies are still not available.'
            );
        }
    }
}

hydephp / develop

Push — master ( ced3fe...73fb21 )

ServeCommand::safeHandle() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
