21323318062

Committed 24 Jan 2026 11:21PM UTC coverage: 27.706% (-2.8%) from 30.503%

Build # 21323318062

Build Type

push

github

Committed by

k0d3r1s

Commit Message

wip

Run Details

1 of 2 new or added lines in 2 files covered. (50.0%)

909 existing lines in 16 files now uncovered.

791 of 2855 relevant lines covered (27.71%)

0.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.93

/Binary/BinaryAssetManager.php

<?php declare(strict_types = 1);

/*
 * This file is part of the Valksor package.
 *
 * (c) Davis Zalitis (k0d3r1s)
 * (c) SIA Valksor <packages@valksor.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ValksorDev\Build\Binary;

use DateTimeImmutable;
use JsonException;
use RuntimeException;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Valksor\Functions\Local\Traits\_MkDir;
use ZipArchive;

use function array_key_exists;
use function chmod;
use function date;
use function escapeshellarg;
use function exec;
use function explode;
use function file_get_contents;
use function file_put_contents;
use function http_get_last_response_headers;
use function implode;
use function in_array;
use function is_array;
use function is_file;
use function json_decode;
use function json_encode;
use function ltrim;
use function php_uname;
use function rename;
use function sleep;
use function sprintf;
use function str_contains;
use function str_starts_with;
use function stream_context_create;
use function strpos;
use function substr;
use function sys_get_temp_dir;
use function trim;
use function uniqid;
use function unlink;

use const DATE_ATOM;
use const JSON_PRETTY_PRINT;
use const JSON_THROW_ON_ERROR;
use const JSON_UNESCAPED_SLASHES;
use const PHP_OS_FAMILY;

/**
 * Generic binary/asset manager for downloading and managing tool binaries and assets from GitHub releases.
 * Supports tailwindcss, esbuild, daisyui, and other tools.
 */
final class BinaryAssetManager
{
    private const string VERSION_FILE = 'version.json';

    /**
     * @param array{
     *     name: string,
     *     source: 'github'|'npm'|'github-zip',
     *     repo?: string,
     *     npm_package?: string,
     *     npm_dist_tag?: string,
     *     assets: array<int,array{pattern:string,target:string,executable:bool,extract_path?:string}>,
     *     target_dir: string,
     *     version_in_path?: bool,
     *     download_strategy?: 'release'|'tag'|'commit',
     *     commit_ref?: string,
     *     pinned_version?: string
     * } $toolConfig
     */
    public function __construct(
        private readonly array $toolConfig,
        private readonly ?ParameterBagInterface $parameterBag = null,
    ) {
    }

    /**
     * @throws JsonException
     */
    public function ensureLatest(
        ?callable $logger = null,
    ): string {
        $targetDir = $this->toolConfig['target_dir'];
        $this->ensureDirectory($targetDir);

        $currentTag = $this->readCurrentTag($targetDir);
        $assetsPresent = $this->assetsPresent($targetDir);

        // Check for pinned version first
        if (isset($this->toolConfig['pinned_version'])) {
            $pinnedVersion = $this->toolConfig['pinned_version'];

            if (null !== $currentTag && $assetsPresent && $currentTag === $pinnedVersion) {
                $this->log($logger, sprintf('%s assets pinned to version %s.', $this->toolConfig['name'], $currentTag));

                return $currentTag;
            }

            // Download pinned version
            $this->log($logger, sprintf('Downloading %s assets (%s)…', $this->toolConfig['name'], $pinnedVersion));

            if ('npm' === $this->toolConfig['source']) {
                $this->downloadNpmAsset($pinnedVersion, $targetDir);
            } elseif ('github-zip' === $this->toolConfig['source'] || in_array($this->toolConfig['download_strategy'] ?? 'release', ['tag', 'commit'], true)) {
                $this->downloadGithubZipAsset($pinnedVersion, $targetDir);
            } else {
                foreach ($this->toolConfig['assets'] as $assetConfig) {
                    $this->downloadAsset($pinnedVersion, $assetConfig, $targetDir);
                }
            }

            $this->writeVersionFile($targetDir, $pinnedVersion, $pinnedVersion);
            $this->log($logger, sprintf('%s assets updated.', $this->toolConfig['name']));

            return $pinnedVersion;
        }

        // Original logic for non-pinned versions
        $downloadStrategy = $this->toolConfig['download_strategy'] ?? 'release';
        $latest = match (true) {
            'npm' === $this->toolConfig['source'] => $this->fetchLatestNpmVersion(),
            'tag' === $downloadStrategy => $this->fetchLatestTag(),
            'commit' === $downloadStrategy => $this->fetchLatestCommit(),
            default => $this->fetchLatestRelease(),
        };

        if (null !== $currentTag && $assetsPresent && $currentTag === $latest['version']) {
            $this->log($logger, sprintf('%s assets already current (%s).', $this->toolConfig['name'], $currentTag));

            return $currentTag;
        }

        $this->log($logger, sprintf('Downloading %s assets (%s)…', $this->toolConfig['name'], $latest['tag']));

        if ('npm' === $this->toolConfig['source']) {
            $this->downloadNpmAsset($latest['version'], $targetDir);
        } elseif ('github-zip' === $this->toolConfig['source'] || in_array($downloadStrategy, ['tag', 'commit'], true)) {
            $this->downloadGithubZipAsset($latest['tag'], $targetDir);
        } else {
            foreach ($this->toolConfig['assets'] as $assetConfig) {
                $this->downloadAsset($latest['tag'], $assetConfig, $targetDir);
            }
        }

        $this->writeVersionFile($targetDir, $latest['tag'], $latest['version']);
        $this->log($logger, sprintf('%s assets updated.', $this->toolConfig['name']));

        return $latest['tag'];
    }

    /**
     * Factory method from custom tool definition array.
     */
    public static function createFromDefinition(
        array $definition,
    ): self {
        if (!isset($definition['name'], $definition['source'], $definition['assets'], $definition['target_dir'])) {
            throw new RuntimeException('Tool definition must include name, source, assets, and target_dir.');
        }

        if (isset($definition['repo'])) {
            throw new RuntimeException('GitHub source requires repo parameter.');
        }

        if (isset($definition['npm_package'])) {
            throw new RuntimeException('npm source requires npm_package parameter.');
        }

        return new self($definition);
    }

    /**
     * Detect current platform for binary downloads.
     */
    public static function detectPlatform(): string
    {
        $os = PHP_OS_FAMILY;
        $arch = php_uname('m');

        if ('Darwin' === $os) {
            return str_contains($arch, 'arm') || str_contains($arch, 'aarch64') ? 'darwin-arm64' : 'darwin-x64';
        }

        if ('Linux' === $os) {
            return str_contains($arch, 'arm') || str_contains($arch, 'aarch64') ? 'linux-arm64' : 'linux-x64';
        }

        if ('Windows' === $os) {
            return 'windows-x64';
        }

        return 'linux-x64'; // Default fallback
    }

    private function assetsPresent(
        string $targetDir,
    ): bool {
        foreach ($this->toolConfig['assets'] as $assetConfig) {
            if (!is_file($targetDir . '/' . $assetConfig['target'])) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param array{pattern:string,target:string,executable:bool} $assetConfig
     */
    private function downloadAsset(
        string $tag,
        array $assetConfig,
        string $targetDir,
    ): void {
        $url = sprintf(
            'https://github.com/%s/releases/download/%s/%s',
            $this->toolConfig['repo'],
            $tag,
            $assetConfig['pattern'],
        );

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => [
                    'User-Agent: valksor-binary-manager',
                ],
                'follow_location' => 1,
                'timeout' => 30,
            ],
        ]);

        $content = @file_get_contents($url, false, $context);

        if (false === $content) {
            throw new RuntimeException(sprintf('Failed to download %s asset: %s', $this->toolConfig['name'], $assetConfig['pattern']));
        }

        $targetPath = $targetDir . '/' . $assetConfig['target'];

        if (false === file_put_contents($targetPath, $content)) {
            throw new RuntimeException(sprintf('Failed to write %s asset to %s', $this->toolConfig['name'], $targetPath));
        }

        if ($assetConfig['executable'] && !chmod($targetPath, 0o755)) {
            throw new RuntimeException(sprintf('Failed to set executable permissions on %s', $targetPath));
        }
    }

    private function downloadGithubZipAsset(
        string $tag,
        string $targetDir,
    ): void {
        $downloadStrategy = $this->toolConfig['download_strategy'] ?? 'release';
        $assetConfig = $this->toolConfig['assets'][0];

        $url = match ($downloadStrategy) {
            'tag', 'commit' => sprintf(
                'https://api.github.com/repos/%s/tarball/%s',
                $this->toolConfig['repo'],
                $tag,
            ),
            default => sprintf(
                'https://github.com/%s/releases/download/%s/%s',
                $this->toolConfig['repo'],
                $tag,
                sprintf($assetConfig['pattern'], ltrim($tag, 'v')),
            ),
        };

        $headers = ['User-Agent: valksor-binary-manager'];

        if (in_array($downloadStrategy, ['tag', 'commit'], true)) {
            $headers[] = 'Accept: application/vnd.github+json';
        }

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => $headers,
                'follow_location' => 1,
                'timeout' => 30,
            ],
        ]);

        $zipContent = @file_get_contents($url, false, $context);

        if (false === $zipContent) {
            throw new RuntimeException(sprintf('Failed to download %s zip: %s', $this->toolConfig['name'], $url));
        }

        $tmpZip = sys_get_temp_dir() . '/valksor-' . uniqid(more_entropy: true) . '.zip';

        if (false === file_put_contents($tmpZip, $zipContent)) {
            throw new RuntimeException(sprintf('Failed to write temporary zip for %s.', $this->toolConfig['name']));
        }

        try {
            $zip = new ZipArchive();

            if (true !== $zip->open($tmpZip)) {
                throw new RuntimeException(sprintf('Unable to open %s zip archive.', $this->toolConfig['name']));
            }

            $zip->extractTo($targetDir);
            $zip->close();
        } finally {
            @unlink($tmpZip);
        }
    }

    private function downloadNpmAsset(
        string $version,
        string $targetDir,
    ): void {
        $assetConfig = $this->toolConfig['assets'][0];

        // Use the actual npm package from configuration instead of hardcoded @esbuild
        $npmPackage = $this->toolConfig['npm_package'];

        // For scoped packages (@scope/package), use the correct URL format
        if (str_starts_with($npmPackage, '@')) {
            $packageName = substr($npmPackage, strpos($npmPackage, '/') + 1);
            $url = sprintf('https://registry.npmjs.org/%s/-/%s-%s.tgz', $npmPackage, $packageName, $version);
        } else {
            // For regular packages, download the full package
            $url = sprintf('https://registry.npmjs.org/%s/-/%s-%s.tgz', $npmPackage, $npmPackage, $version);
        }

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => 'User-Agent: valksor-binary-manager',
                'follow_location' => 1,
                'timeout' => 30,
            ],
        ]);

        $tgzContent = @file_get_contents($url, false, $context);

        if (false === $tgzContent) {
            throw new RuntimeException(sprintf('Failed to download %s from npm registry: %s', $this->toolConfig['name'], $url));
        }

        $tmpDir = sys_get_temp_dir() . '/valksor-binary-' . uniqid(more_entropy: true);
        $this->ensureDirectory($tmpDir);

        try {
            $tgzPath = $tmpDir . '/package.tgz';

            if (false === file_put_contents($tgzPath, $tgzContent)) {
                throw new RuntimeException(sprintf('Failed to write temporary tarball for %s.', $this->toolConfig['name']));
            }

            $extractPath = $assetConfig['extract_path'] ?? 'package/bin/esbuild';
            $extractDir = $tmpDir . '/extracted';
            $this->ensureDirectory($extractDir);

            // Extract the entire tarball
            exec(sprintf('tar -xzf %s -C %s 2>&1', escapeshellarg($tgzPath), escapeshellarg($extractDir)), $output, $returnCode);

            if (0 !== $returnCode) {
                throw new RuntimeException(sprintf('Failed to extract %s tarball: %s', $this->toolConfig['name'], implode("\n", $output)));
            }

            // Handle both file and directory extraction
            $sourcePath = $extractDir . '/' . $extractPath;
            $targetPath = $targetDir . '/' . $assetConfig['target'];

            // If target is '.', copy the entire extracted directory
            if ('.' === $assetConfig['target']) {
                // Copy entire extracted directory contents to target
                exec(sprintf('cp -r %s/* %s/ 2>&1', escapeshellarg($sourcePath), escapeshellarg($targetDir)), $output, $returnCode);

                if (0 !== $returnCode) {
                    throw new RuntimeException(sprintf('Failed to copy %s package: %s', $this->toolConfig['name'], implode("\n", $output)));
                }
            } else {
                // Original behavior: move specific file
                if (!is_file($sourcePath)) {
                    throw new RuntimeException(sprintf('Extracted binary not found at %s', $sourcePath));
                }

                if (!rename($sourcePath, $targetPath)) {
                    throw new RuntimeException(sprintf('Failed to move %s binary to %s', $this->toolConfig['name'], $targetPath));
                }
            }

            if ($assetConfig['executable'] && !chmod($targetPath, 0o755)) {
                throw new RuntimeException(sprintf('Failed to set executable permissions on %s', $targetPath));
            }
        } finally {
            exec(sprintf('rm -rf %s 2>&1', escapeshellarg($tmpDir)));
        }
    }

    private function ensureDirectory(
        string $directory,
    ): void {
        static $_helper = null;

        if (null === $_helper) {
            $_helper = new class {
                use _MkDir;
            };
        }

        $_helper->mkdir($directory);
    }

    /**
     * Extract HTTP status code from response headers.
     */
    private function extractHttpStatusCode(
        array $headers,
    ): int {
        foreach ($headers as $header) {
            if (str_starts_with($header, 'HTTP/')) {
                $parts = explode(' ', $header);

                return (int) ($parts[1] ?? 0);
            }
        }

        return 0;
    }

    /**
     * @return array{tag: string, version: string}
     */
    private function fetchLatestCommit(): array
    {
        $commitRef = $this->toolConfig['commit_ref'] ?? $this->getDefaultBranch();

        $apiUrl = sprintf('https://api.github.com/repos/%s/commits/%s', $this->toolConfig['repo'], $commitRef);

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => [
                    'User-Agent: valksor-binary-manager',
                    'Accept: application/vnd.github+json',
                ],
                'timeout' => 15,
            ],
        ]);

        $response = @file_get_contents($apiUrl, false, $context);

        if (false === $response) {
            throw new RuntimeException(sprintf('Failed to fetch commit %s for %s from GitHub API.', $commitRef, $this->toolConfig['name']));
        }

        try {
            $commit = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
        } catch (JsonException $exception) {
            throw new RuntimeException(sprintf('Invalid JSON response from GitHub API for %s commit: %s', $this->toolConfig['name'], $exception->getMessage()));
        }

        if (!array_key_exists('sha', $commit)) {
            throw new RuntimeException(sprintf('Unexpected GitHub API commit response structure for %s.', $this->toolConfig['name']));
        }

        $shortSha = substr($commit['sha'], 0, 7);

        return [
            'tag' => $shortSha,
            'version' => $shortSha,
        ];
    }

    /**
     * @return array{tag: string, version: string}
     */
    private function fetchLatestNpmVersion(): array
    {
        $distTag = $this->toolConfig['npm_dist_tag'] ?? 'latest';
        $packageUrl = sprintf('https://registry.npmjs.org/%s/%s', $this->toolConfig['npm_package'], $distTag);

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => 'User-Agent: valksor-binary-manager',
                'timeout' => 15,
            ],
        ]);

        $response = @file_get_contents($packageUrl, false, $context);

        if (false === $response) {
            throw new RuntimeException(sprintf('Failed to fetch latest version for %s from npm registry.', $this->toolConfig['name']));
        }

        try {
            $data = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
        } catch (JsonException $exception) {
            throw new RuntimeException(sprintf('Invalid JSON response from npm registry for %s: %s', $this->toolConfig['name'], $exception->getMessage()));
        }

        if (!array_key_exists('version', $data)) {
            throw new RuntimeException(sprintf('Unexpected npm registry response structure for %s.', $this->toolConfig['name']));
        }

        return [
            'tag' => $data['version'],
            'version' => $data['version'],
        ];
    }

    /**
     * @return array{tag: string, version: string}
     */
    private function fetchLatestRelease(): array
    {
        if ('npm' === $this->toolConfig['source']) {
            return $this->fetchLatestNpmVersion();
        }

        $maxRetries = 3;
        $baseDelay = 2; // seconds

        for ($attempt = 1; $attempt <= $maxRetries; $attempt++) {
            try {
                return $this->fetchLatestReleaseWithRetry($attempt);
            } catch (RuntimeException $exception) {
                // Don't retry on rate limit errors with explicit guidance
                if ($this->isRateLimitError($exception->getMessage())) {
                    throw $exception;
                }

                // Retry on other failures with exponential backoff
                if ($attempt < $maxRetries) {
                    $delay = $baseDelay ** $attempt;
                    sleep($delay);

                    continue;
                }

                throw $exception;
            }
        }

        throw new RuntimeException(sprintf('Failed to fetch latest release for %s after %d attempts.', $this->toolConfig['name'], $maxRetries));
    }

    /**
     * @return array{tag: string, version: string}
     */
    private function fetchLatestReleaseWithRetry(
        int $attempt,
    ): array {
        $apiUrl = sprintf('https://api.github.com/repos/%s/releases/latest', $this->toolConfig['repo']);

        // Build headers with optional GitHub token
        $headers = [
            'User-Agent: valksor-binary-manager',
            'Accept: application/vnd.github+json',
        ];

        $githubToken = $this->getGitHubToken();

        if ($githubToken) {
            $headers[] = 'Authorization: token ' . $githubToken;
        }

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => $headers,
                'timeout' => 15,
                'ignore_errors' => true, // Allow us to read response headers even on errors
            ],
        ]);

        $response = @file_get_contents($apiUrl, false, $context);

        // Check HTTP response code
        $responseHeaders = http_get_last_response_headers();

        if (null !== $responseHeaders) {
            $statusCode = $this->extractHttpStatusCode($responseHeaders);

            if (403 === $statusCode) {
                $rateLimitInfo = $this->parseRateLimitHeaders($responseHeaders);

                if (0 === $rateLimitInfo['remaining']) {
                    $resetTime = $rateLimitInfo['reset'] ? date('Y-m-d H:i:s', $rateLimitInfo['reset']) : 'unknown';
                    $message = sprintf(
                        'GitHub API rate limit exceeded for %s. Reset time: %s. ' .
                        'To increase rate limit, set valksor.build.github_token parameter',
                        $this->toolConfig['name'],
                        $resetTime,
                    );

                    throw new RuntimeException($message);
                }

                throw new RuntimeException(sprintf('Access forbidden to GitHub API for %s (HTTP 403).', $this->toolConfig['name']));
            }

            if (404 === $statusCode) {
                throw new RuntimeException(sprintf('GitHub repository or releases not found for %s (HTTP 404).', $this->toolConfig['name']));
            }

            if ($statusCode >= 400) {
                throw new RuntimeException(sprintf('GitHub API returned HTTP %d for %s.', $statusCode, $this->toolConfig['name']));
            }
        }

        if (false === $response) {
            $errorMsg = sprintf('Failed to fetch latest release for %s from GitHub API', $this->toolConfig['name']);

            if ($attempt > 1) {
                $errorMsg .= sprintf(' (attempt %d/%d)', $attempt, 3);
            }

            throw new RuntimeException($errorMsg . '.');
        }

        try {
            $data = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
        } catch (JsonException $exception) {
            throw new RuntimeException(sprintf('Invalid JSON response from GitHub API for %s: %s', $this->toolConfig['name'], $exception->getMessage()));
        }

        if (!array_key_exists('tag_name', $data)) {
            throw new RuntimeException(sprintf('Unexpected GitHub API response structure for %s.', $this->toolConfig['name']));
        }

        return [
            'tag' => $data['tag_name'],
            'version' => $data['name'] ?? $data['tag_name'],
        ];
    }

    /**
     * @return array{tag: string, version: string}
     */
    private function fetchLatestTag(): array
    {
        $apiUrl = sprintf('https://api.github.com/repos/%s/tags', $this->toolConfig['repo']);

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => [
                    'User-Agent: valksor-binary-manager',
                    'Accept: application/vnd.github+json',
                ],
                'timeout' => 15,
            ],
        ]);

        $response = @file_get_contents($apiUrl, false, $context);

        if (false === $response) {
            throw new RuntimeException(sprintf('Failed to fetch latest tag for %s from GitHub API.', $this->toolConfig['name']));
        }

        try {
            $tags = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
        } catch (JsonException $exception) {
            throw new RuntimeException(sprintf('Invalid JSON response from GitHub API for %s tags: %s', $this->toolConfig['name'], $exception->getMessage()));
        }

        if (!is_array($tags) || empty($tags)) {
            throw new RuntimeException(sprintf('No tags found for %s repository.', $this->toolConfig['name']));
        }

        $latestTag = $tags[0];

        if (!array_key_exists('name', $latestTag)) {
            throw new RuntimeException(sprintf('Unexpected GitHub API tags response structure for %s.', $this->toolConfig['name']));
        }

        $tagName = $latestTag['name'];

        return [
            'tag' => $tagName,
            'version' => $tagName,
        ];
    }

    /**
     * Get the default branch for the repository.
     */
    private function getDefaultBranch(): string
    {
        $apiUrl = sprintf('https://api.github.com/repos/%s', $this->toolConfig['repo']);

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => [
                    'User-Agent: valksor-binary-manager',
                    'Accept: application/vnd.github+json',
                ],
                'timeout' => 15,
            ],
        ]);

        $response = @file_get_contents($apiUrl, false, $context);

        if (false === $response) {
            throw new RuntimeException(sprintf('Failed to fetch repository info for %s from GitHub API.', $this->toolConfig['name']));
        }

        try {
            $repo = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
        } catch (JsonException $exception) {
            throw new RuntimeException(sprintf('Invalid JSON response from GitHub API for %s repository: %s', $this->toolConfig['name'], $exception->getMessage()));
        }

        if (!array_key_exists('default_branch', $repo)) {
            throw new RuntimeException(sprintf('Unexpected GitHub API repository response structure for %s.', $this->toolConfig['name']));
        }

        return $repo['default_branch'];
    }

    /**
     * Get GitHub token from parameter bag or environment variable.
     */
    private function getGitHubToken(): ?string
    {
        // Try parameter bag first
        if ($this->parameterBag && $this->parameterBag->has('valksor.build.github_token')) {
            return $this->parameterBag->get('valksor.build.github_token');
        }

        // Fallback to environment variable
        return null;
    }

    /**
     * Check if an error message indicates a rate limit issue.
     */
    private function isRateLimitError(
        string $message,
    ): bool {
        return str_contains($message, 'rate limit') || str_contains($message, 'Rate limit');
    }

    private function log(
        ?callable $logger,
        string $message,
    ): void {
        if (null !== $logger) {
            $logger($message);
        }
    }

    /**
     * Parse rate limit information from response headers.
     */
    private function parseRateLimitHeaders(
        array $headers,
    ): array {
        $rateLimitInfo = [
            'limit' => null,
            'remaining' => null,
            'reset' => null,
        ];

        foreach ($headers as $header) {
            if (str_starts_with($header, 'X-RateLimit-Limit:')) {
                $rateLimitInfo['limit'] = (int) trim(substr($header, 19));
            } elseif (str_starts_with($header, 'X-RateLimit-Remaining:')) {
                $rateLimitInfo['remaining'] = (int) trim(substr($header, 23));
            } elseif (str_starts_with($header, 'X-RateLimit-Reset:')) {
                $rateLimitInfo['reset'] = (int) trim(substr($header, 19));
            }
        }

        return $rateLimitInfo;
    }

    private function readCurrentTag(
        string $targetDir,
    ): ?string {
        $versionFile = $targetDir . '/' . self::VERSION_FILE;

        if (!is_file($versionFile)) {
            return null;
        }

        $raw = @file_get_contents($versionFile);

        if (false === $raw || '' === $raw) {
            return null;
        }

        try {
            $data = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
        } catch (JsonException) {
            return null;
        }

        return array_key_exists('tag', $data) ? (string) $data['tag'] : null;
    }

    /**
     * @throws JsonException
     */
    private function writeVersionFile(
        string $targetDir,
        string $tag,
        string $version,
    ): void {
        $data = [
            'tag' => $tag,
            'version' => $version,
            'downloaded_at' => new DateTimeImmutable()->format(DATE_ATOM),
        ];

        $json = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
        $versionFile = $targetDir . '/' . self::VERSION_FILE;

        if (false === file_put_contents($versionFile, $json)) {
            throw new RuntimeException(sprintf('Failed to write version file for %s.', $this->toolConfig['name']));
        }
    }
}

valksor / php-dev-build / 21323318062

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous