KevinGH\Box\Box

Complexity

Total Complexity

42

Size/Duplication

Total Lines	384
Duplicated Lines	8.59 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	addFile()	0	18	4
C	buildFromIterator()	0	51	10
A	setValues()	0	12	3
A	getPhar()	0	3	1
A	addCompactor()	0	3	1
B	sign()	0	34	6
A	buildFromDirectory()	0	16	2
A	addFromString()	0	5	1
A	setStubUsingFile()	18	18	4
A	create()	0	3	1
A	getSignature()	0	3	1
A	compactContents()	0	10	3
A	replaceValues()	0	6	1
A	signUsingFile()	14	14	3
A	__construct()	0	5	1

<?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 FilesystemIterator;
use KevinGH\Box\Compactor\Compactor;

This use statement conflicts with another class in this namespace, KevinGH\Box\Compactor. Consider defining an alias.

use KevinGH\Box\Compactor\CompactorInterface;

The type KevinGH\Box\Compactor\CompactorInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use KevinGH\Box\Exception\FileException;
use KevinGH\Box\Exception\InvalidArgumentException;
use KevinGH\Box\Exception\OpenSslException;
use KevinGH\Box\Exception\UnexpectedValueException;
use Phar;
use Phine\Path\Path;

The type Phine\Path\Path was not found. Maybe you did not declare it correctly or list all dependencies?

use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use RegexIterator;
use SplFileInfo;
use SplObjectStorage;
use Traversable;

/**
 * Provides additional, complimentary functionality to the Phar class.
 *
 * @author Kevin Herrera <kevin@herrera.io>
 */
class Box
{
    /**
     * The source code compactors.
     *
     * @var SplObjectStorage
     */
    private $compactors;

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

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

    /**
     * The placeholder values.
     *
     * @var array
     */
    private $values = [];

    /**
     * Sets the Phar instance.
     *
     * @param Phar   $phar the instance
     * @param string $file the path to the Phar file
     */
    public function __construct(Phar $phar, $file)
    {
        $this->compactors = new SplObjectStorage();
        $this->file = $file;
        $this->phar = $phar;
    }

    /**
     * Adds a file contents compactor.
     *
     * @param Compactor $compactor the compactor
     */
    public function addCompactor(Compactor $compactor): void
    {
        $this->compactors->attach($compactor);
    }

    /**
     * Adds a file to the Phar, after compacting it and replacing its
     * placeholders.
     *
     * @param string $file  the file name
     * @param string $local the local file name
     *
     * @throws Exception\Exception
     * @throws FileException       if the file could not be used
     */
    public function addFile($file, $local = null): void
    {
        if (null === $local) {
            $local = $file;
        }

        if (false === is_file($file)) {
            throw FileException::create(
                'The file "%s" does not exist or is not a file.',
                $file
            );
        }

        if (false === ($contents = @file_get_contents($file))) {
            throw FileException::lastError();
        }

        $this->addFromString($local, $contents);
    }

    /**
     * Adds the contents from a file to the Phar, after compacting it and
     * replacing its placeholders.
     *
     * @param string $local    the local name
     * @param string $contents the contents
     */
    public function addFromString($local, $contents): void
    {
        $this->phar->addFromString(
            $local,
            $this->replaceValues($this->compactContents($local, $contents))
        );
    }

    /**
     * Similar to Phar::buildFromDirectory(), except the files will be
     * compacted and their placeholders replaced.
     *
     * @param string $dir   the directory
     * @param string $regex the regular expression filter
     */
    public function buildFromDirectory($dir, $regex = null): void
    {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator(
                $dir,
                FilesystemIterator::KEY_AS_PATHNAME
                | FilesystemIterator::CURRENT_AS_FILEINFO
                | FilesystemIterator::SKIP_DOTS
            )
        );

        if ($regex) {

The expression $regex of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $iterator = new RegexIterator($iterator, $regex);
        }

        $this->buildFromIterator($iterator, $dir);
    }

    /**
     * Similar to Phar::buildFromIterator(), except the files will be compacted
     * and their placeholders replaced.
     *
     * @param Traversable $iterator the iterator
     * @param string      $base     the base directory path
     *
     * @throws Exception\Exception
     * @throws UnexpectedValueException if the iterator value is unexpected
     */
    public function buildFromIterator(Traversable $iterator, $base = null): void
    {
        if ($base) {

The expression $base of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $base = canonicalize($base.DIRECTORY_SEPARATOR);
        }

        foreach ($iterator as $key => $value) {
            if (is_string($value)) {
                if (false === is_string($key)) {
                    throw UnexpectedValueException::create(
                        'The key returned by the iterator (%s) is not a string.',
                        gettype($key)
                    );
                }

                $key = canonicalize($key);
                $value = canonicalize($value);

                if (is_dir($value)) {
                    $this->phar->addEmptyDir($key);
                } else {
                    $this->addFile($value, $key);
                }
            } elseif ($value instanceof SplFileInfo) {
                if (null === $base) {
                    throw InvalidArgumentException::create(
                        'The $base argument is required for SplFileInfo values.'
                    );
                }

                /** @var $value SplFileInfo */
                $real = $value->getRealPath();

                if (0 !== strpos($real, $base)) {
                    throw UnexpectedValueException::create(
                        'The file "%s" is not in the base directory.',
                        $real
                    );
                }

                $local = str_replace($base, '', $real);

                if ($value->isDir()) {
                    $this->phar->addEmptyDir($local);
                } else {
                    $this->addFile($real, $local);
                }
            } else {
                throw UnexpectedValueException::create(
                    'The iterator value "%s" was not expected.',
                    gettype($value)
                );
            }
        }
    }

    /**
     * Compacts the file contents using the supported compactors.
     *
     * @param string $file     the file name
     * @param string $contents the file contents
     *
     * @return string the compacted contents
     */
    public function compactContents($file, $contents)
    {
        foreach ($this->compactors as $compactor) {
            /** @var $compactor CompactorInterface */
            if ($compactor->supports($file)) {
                $contents = $compactor->compact($contents);
            }
        }

        return $contents;
    }

    /**
     * Creates a new Phar and Box instance.
     *
     * @param string $file  the file name
     * @param int    $flags the RecursiveDirectoryIterator flags
     * @param string $alias the Phar alias
     *
     * @return Box the Box instance
     */
    public static function create($file, $flags = null, $alias = null)
    {
        return new self(new Phar($file, (int) $flags, $alias), $file);
    }

    /**
     * Returns the Phar instance.
     *
     * @return Phar the instance
     */
    public function getPhar()
    {
        return $this->phar;
    }

    /**
     * Returns the signature of the phar.
     *
     * This method does not use the extension to extract the phar's signature.
     *
     * @param string $path the phar file path
     *
     * @return array the signature
     */
    public static function getSignature($path)
    {
        return Signature::create($path)->get();
    }

    /**
     * Replaces the placeholders with their values.
     *
     * @param string $contents the contents
     *
     * @return string the replaced contents
     */
    public function replaceValues($contents)
    {
        return str_replace(
            array_keys($this->values),
            array_values($this->values),
            $contents
        );
    }

    /**
     * Sets the bootstrap loader stub using a file.
     *
     * @param string $file    the file path
     * @param bool   $replace Replace placeholders?
     *
     * @throws Exception\Exception
     * @throws FileException       if the stub file could not be used
     */
    public function setStubUsingFile($file, $replace = false): void

This method seems to be duplicated in your project.

    {
        if (false === is_file($file)) {
            throw FileException::create(
                'The file "%s" does not exist or is not a file.',
                $file
            );
        }

        if (false === ($contents = @file_get_contents($file))) {
            throw FileException::lastError();
        }

        if ($replace) {
            $contents = $this->replaceValues($contents);
        }

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

    /**
     * Sets the placeholder values.
     *
     * @param array $values the values
     *
     * @throws Exception\Exception
     * @throws InvalidArgumentException if a non-scalar value is used
     */
    public function setValues(array $values): void
    {
        foreach ($values as $value) {
            if (false === is_scalar($value)) {
                throw InvalidArgumentException::create(
                    'Non-scalar values (such as %s) are not supported.',
                    gettype($value)
                );
            }
        }

        $this->values = $values;
    }

    /**
     * Signs the Phar using a private key.
     *
     * @param string $key      the private key
     * @param string $password the private key password
     *
     * @throws Exception\Exception
     * @throws OpenSslException    if the "openssl" extension could not be used
     *                             or has generated an error
     */
    public function sign($key, $password = null): void
    {
        OpenSslException::reset();

        if (false === extension_loaded('openssl')) {
            // @codeCoverageIgnoreStart
            throw OpenSslException::create(
                'The "openssl" extension is not available.'
            );
            // @codeCoverageIgnoreEnd
        }

        if (false === ($resource = openssl_pkey_get_private($key, $password))) {
            // @codeCoverageIgnoreStart
            throw OpenSslException::lastError();
            // @codeCoverageIgnoreEnd
        }

        if (false === openssl_pkey_export($resource, $private)) {
            // @codeCoverageIgnoreStart
            throw OpenSslException::lastError();
            // @codeCoverageIgnoreEnd
        }

        if (false === ($details = openssl_pkey_get_details($resource))) {
            // @codeCoverageIgnoreStart
            throw OpenSslException::lastError();
            // @codeCoverageIgnoreEnd
        }

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

        if (false === @file_put_contents($this->file.'.pubkey', $details['key'])) {
            throw FileException::lastError();
        }
    }

    /**
     * Signs the Phar using a private key file.
     *
     * @param string $file     the private key file name
     * @param string $password the private key password
     *
     * @throws Exception\Exception
     * @throws FileException       if the private key file could not be read
     */
    public function signUsingFile($file, $password = null): void

This method seems to be duplicated in your project.

    {
        if (false === is_file($file)) {
            throw FileException::create(
                'The file "%s" does not exist or is not a file.',
                $file
            );
        }

        if (false === ($key = @file_get_contents($file))) {
            throw FileException::lastError();
        }

        $this->sign($key, $password);
    }
}