KevinGH\Box\Box

Complexity

Total Complexity

32

Size/Duplication

Total Lines	372
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
B	addFile()	0	36	6
B	processContents()	0	31	3
A	getPhar()	0	3	1
A	registerCompactors()	0	11	3
A	sign()	0	23	2
A	registerStub()	0	8	1
A	replacePlaceholders()	0	6	1
A	registerPlaceholders()	0	17	3
A	create()	0	7	1
A	registerFileMapping()	0	4	1
A	compactContents()	0	8	1
B	addFiles()	0	48	5
A	signUsingFile()	0	3	1
A	__construct()	0	7	1
A	dumpFiles()	0	21	2

<?php

declare(strict_types=1);

/*
 * This file is part of the box project.
 *
 * (c) Kevin Herrera <kevin@herrera.io>
 *     Théo Fidry <theo.fidry@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace KevinGH\Box;

use Assert\Assertion;
use const DIRECTORY_SEPARATOR;
use Humbug\PhpScoper\Console\Configuration as PhpScoperConfiguration;
use KevinGH\Box\Compactor\PhpScoper;
use KevinGH\Box\Composer\ComposerOrchestrator;
use function KevinGH\Box\FileSystem\make_path_absolute;
use Phar;
use RecursiveDirectoryIterator;
use SplFileInfo;
use function Amp\ParallelFunctions\parallelMap;
use function Amp\Promise\wait;
use function array_map;
use function chdir;
use function is_file;
use function KevinGH\Box\FileSystem\copy;
use function KevinGH\Box\FileSystem\dump_file;
use function KevinGH\Box\FileSystem\file_contents;
use function KevinGH\Box\FileSystem\make_path_relative;
use function KevinGH\Box\FileSystem\make_tmp_dir;
use function KevinGH\Box\FileSystem\mkdir;
use function KevinGH\Box\FileSystem\remove;
use function KevinGH\Box\FileSystem\rename;

/**
 * Box is a utility class to generate a PHAR.
 */
final class Box
{
    private const DEBUG_DIR = '.box';

    /**
     * @var Compactor[]
     */
    private $compactors = [];

    /**
     * @var string The path to the PHAR file
     */
    private $file;

    /**
     * @var Phar The PHAR instance
     */
    private $phar;

    /**
     * @var scalar[] The placeholders with their values
     */
    private $placeholders = [];

    /**
     * @var string
     */
    private $basePath;

    /**
     * @var MapFile
     */
    private $mapFile;

    /**
     * @var null|PhpScoperConfiguration
     */
    private $phpScoperConfig;

    private function __construct(Phar $phar, string $file)
    {
        $this->phar = $phar;
        $this->file = $file;

        $this->basePath = getcwd();
        $this->mapFile = function (): void { };
    }

    /**
     * Creates a new PHAR and Box instance.
     *
     * @param string $file  The PHAR file name
     * @param int    $flags Flags to pass to the Phar parent class RecursiveDirectoryIterator
     * @param string $alias Alias with which the Phar archive should be referred to in calls to stream functionality
     *
     * @return Box
     *
     * @see RecursiveDirectoryIterator
     */
    public static function create(string $file, int $flags = null, string $alias = null): self
    {
        // Ensure the parent directory of the PHAR file exists as `new \Phar()` does not create it and would fail
        // otherwise.
        mkdir(dirname($file));

        return new self(new Phar($file, (int) $flags, $alias), $file);
    }

    /**
     * @param Compactor[] $compactors
     */
    public function registerCompactors(array $compactors): void
    {
        Assertion::allIsInstanceOf($compactors, Compactor::class);

        $this->compactors = $compactors;

        foreach ($this->compactors as $compactor) {
            if ($compactor instanceof PhpScoper) {
                $this->phpScoperConfig = $compactor->getConfiguration();

                break;
            }
        }
    }

    /**
     * @param scalar[] $placeholders
     */
    public function registerPlaceholders(array $placeholders): void
    {
        $message = 'Expected value "%s" to be a scalar or stringable object.';

        foreach ($placeholders as $i => $placeholder) {
            if (is_object($placeholder)) {
                Assertion::methodExists('__toString', $placeholder, $message);

                $placeholders[$i] = (string) $placeholder;

                break;
            }

            Assertion::scalar($placeholder, $message);
        }

        $this->placeholders = $placeholders;
    }

    public function registerFileMapping(string $basePath, MapFile $fileMapper): void
    {
        $this->basePath = $basePath;
        $this->mapFile = $fileMapper;
    }

    public function registerStub(string $file): void
    {
        $contents = self::replacePlaceholders(
            $this->placeholders,
            file_contents($file)
        );

        $this->phar->setStub($contents);
    }

    /**
     * @param SplFileInfo[]|string[] $files
     * @param bool                   $binary
     */
    public function addFiles(array $files, bool $binary): void
    {
        if ($binary) {
            foreach ($files as $file) {
                $this->addFile((string) $file, null, $binary);
            }

            return;
        }

        $cwd = getcwd();

        $filesWithContents = $this->processContents(
            array_map(
                function ($file): string {
                    // Convert files to string as SplFileInfo is not serializable
                    return (string) $file;
                },
                $files
            ),
            $cwd
        );

        $tmp = make_tmp_dir('box', __CLASS__);
        chdir($tmp);

        try {
            foreach ($filesWithContents as $fileWithContents) {
                [$file, $contents] = $fileWithContents;

                dump_file($file, $contents);
            }

            // Dump autoload without dev dependencies
            ComposerOrchestrator::dumpAutoload($this->phpScoperConfig);

            chdir($cwd);

            $this->phar->buildFromDirectory($tmp);
        } finally {
            if (is_debug_enabled()) {
                $this->dumpFiles(
                    make_path_absolute(self::DEBUG_DIR, $cwd),
                    $tmp
                );
            }

            remove($tmp);
        }
    }

    /**
     * Adds the a file to the PHAR. The contents will first be compacted and have its placeholders
     * replaced.
     *
     * @param string      $file
     * @param null|string $contents If null the content of the file will be used
     * @param bool        $binary   When true means the file content shouldn't be processed
     *
     * @return string File local path
     */
    public function addFile(string $file, string $contents = null, bool $binary = false): string
    {
        Assertion::file($file);
        Assertion::readable($file);

        $contents = null === $contents ? file_get_contents($file) : $contents;

        $relativePath = make_path_relative($file, $this->basePath);
        $local = ($this->mapFile)($relativePath);

        if (null === $local) {
            $local = $relativePath;
        }

        if ($binary) {
            $this->phar->addFile($file, $local);
        } else {
            $processedContents = self::compactContents(
                $this->compactors,
                $local,
                self::replacePlaceholders($this->placeholders, $contents)
            );

            $this->phar->addFromString($local, $processedContents);
        }

        if (is_debug_enabled()) {
            if (false === $processedContents) {

The variable $processedContents does not seem to be defined for all execution paths leading up to this point.

                $processedContents = $contents;
            }

            remove(self::DEBUG_DIR);    // Cleanup previous temporary debug directory
            dump_file(self::DEBUG_DIR.DIRECTORY_SEPARATOR.$relativePath, $processedContents);
        }

        return $local;
    }

    public function getPhar(): Phar
    {
        return $this->phar;
    }

    /**
     * Signs the PHAR using a private key file.
     *
     * @param string $file     the private key file name
     * @param string $password the private key password
     */
    public function signUsingFile(string $file, string $password = null): void
    {
        $this->sign(file_contents($file), $password);
    }

    /**
     * Signs the PHAR using a private key.
     *
     * @param string $key      The private key
     * @param string $password The private key password
     */
    public function sign(string $key, ?string $password): void
    {
        $pubKey = $this->file.'.pubkey';

        Assertion::writeable(dirname($pubKey));
        Assertion::extensionLoaded('openssl');

        if (file_exists($pubKey)) {
            Assertion::file(
                $pubKey,
                'Cannot create public key: "%s" already exists and is not a file.'
            );
        }

        $resource = openssl_pkey_get_private($key, (string) $password);

        openssl_pkey_export($resource, $private);

        $details = openssl_pkey_get_details($resource);

It seems like $resource can also be of type false; however, parameter $key of openssl_pkey_get_details() does only seem to accept resource, maybe add an additional type check?

        $this->phar->setSignatureAlgorithm(Phar::OPENSSL, $private);

        dump_file($pubKey, $details['key']);
    }

    /**
     * @param string[] $files
     * @param string   $cwd   Current working directory. As the processes are spawned for parallel processing, the
     *                        working directory may change so we pass the working directory in which the processing
     *                        is supposed to happen. This should not happen during regular usage as all the files are
     *                        absolute but it's possible this class is used with relative paths in which case this is
     *                        an issue.
     *
     * @return array array of tuples where the first element is the local file path (path inside the PHAR) and the
     *               second element is the processed contents
     */
    private function processContents(array $files, string $cwd): array
    {
        $basePath = $this->basePath;
        $mapFile = $this->mapFile;
        $placeholders = $this->placeholders;
        $compactors = $this->compactors;

        $processFile = function (string $file) use ($cwd, $basePath, $mapFile, $placeholders, $compactors): array {
            chdir($cwd);

            $contents = file_contents($file);

            $relativePath = make_path_relative($file, $basePath);
            $local = $mapFile($relativePath);

            if (null === $local) {
                $local = $relativePath;
            }

            $processedContents = self::compactContents(
                $compactors,
                $local,
                self::replacePlaceholders($placeholders, $contents)
            );

            return [$local, $processedContents];
        };

        return is_debug_enabled()
            ? array_map($processFile, $files)
            : wait(parallelMap($files, $processFile))
        ;
    }

    /**
     * Replaces the placeholders with their values.
     *
     * @param array  $placeholders
     * @param string $contents     the contents
     *
     * @return string the replaced contents
     */
    private static function replacePlaceholders(array $placeholders, string $contents): string
    {
        return str_replace(
            array_keys($placeholders),
            array_values($placeholders),
            $contents
        );
    }

    private static function compactContents(array $compactors, string $file, string $contents): string
    {
        return array_reduce(
            $compactors,
            function (string $contents, Compactor $compactor) use ($file): string {
                return $compactor->compact($file, $contents);
            },
            $contents
        );
    }

    /**
     * Dumps the files added to the PHAR into a directory at the project level to allow the user to easily have a look.
     * At this point only the main script should have already been registered into the dump target.
     */
    private function dumpFiles(string $debugDir, string $tmp): void
    {
        $mainScript = current(
            array_filter(
                scandir($debugDir, 1),
                function (string $file): bool {
                    return false === in_array($file, ['.', '..'], true);
                }
            )
        );

        $sourceMainScript = $debugDir.DIRECTORY_SEPARATOR.$mainScript;
        $targetMainScript = $tmp.DIRECTORY_SEPARATOR.$mainScript;

        if (is_file($mainScript)) {
            copy($sourceMainScript, $targetMainScript);
        } else {
            rename($sourceMainScript, $targetMainScript);
        }

        rename($tmp, $debugDir, true);
    }
}