TarByPhar::canStream() - Code Metrics - Inspection of "New driver - NelexaZip and update docs" - wapmorgan/UnifiedArchive - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( b1d4f6...7824cd )

by f
created 2022-06-30 22:18 UTC
TarByPhar::canStream() A

↳ Parent: TarByPhar::createArchive()
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1.2963
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
ccs	1
cts	3
cp	0.3333
crap	1.2963
rs	10
c	1
b	0
f	0
<?php
namespace wapmorgan\UnifiedArchive\Drivers;

use Exception;
use FilesystemIterator;
use Phar;
use PharData;
use PharFileInfo;
use RecursiveIteratorIterator;
use Vtiful\Kernel\Format;
use wapmorgan\UnifiedArchive\ArchiveEntry;
use wapmorgan\UnifiedArchive\ArchiveInformation;
use wapmorgan\UnifiedArchive\Drivers\BasicDriver;
use wapmorgan\UnifiedArchive\Exceptions\ArchiveCreationException;
use wapmorgan\UnifiedArchive\Exceptions\ArchiveExtractionException;
use wapmorgan\UnifiedArchive\Exceptions\ArchiveModificationException;
use wapmorgan\UnifiedArchive\Exceptions\UnsupportedOperationException;
use wapmorgan\UnifiedArchive\Formats;

class TarByPhar extends BasicDriver
{
    public static $disabled = false;

    /**
     * @var false|string
     */
    protected $archiveFileName;

    /**
     * @var PharData
     */
    protected $tar;

    /**
     * @var float
     */
    protected $compressRatio;

    protected $pureFilesNumber;

    /**
     * @var int Flags for iterator
     */
    const PHAR_FLAGS = FilesystemIterator::UNIX_PATHS;

    /**
     * @return array
     */
    public static function getSupportedFormats()
    {
        return [
            Formats::TAR,
            Formats::TAR_GZIP,
            Formats::TAR_BZIP,
            Formats::ZIP,
        ];
    }

    /**
     * @param $format
     * @return array
     */
    public static function checkFormatSupport($format)
    {
        if (static::$disabled || !class_exists('\PharData')) {
            return [];
        }

        $abilities = [
            BasicDriver::OPEN,
            BasicDriver::EXTRACT_CONTENT,
            BasicDriver::STREAM_CONTENT,
            BasicDriver::APPEND,
            BasicDriver::DELETE,
            BasicDriver::CREATE,
        ];

        switch ($format) {
            case Formats::TAR:
            case Formats::ZIP:
                return $abilities;

            case Formats::TAR_GZIP:
                return extension_loaded('zlib')
                    ? $abilities
                    : [];
            case Formats::TAR_BZIP:
                return extension_loaded('bz2')
                    ? $abilities
                    : [];
        }
    }

    /**
     * @inheritDoc
     */
    public static function getDescription()
    {
        return 'adapter for ext-phar';
    }

    /**
     * @inheritDoc
     */
    public static function getInstallationInstruction()
    {
        return !extension_loaded('phar')
            ? 'install `phar` extension and optionally php-extensions (zlib, bzip2)'
            : null;
    }

    /**
     * @inheritDoc
     */
    public function __construct($archiveFileName, $format, $password = null)
    {
        $this->archiveFileName = realpath($archiveFileName);
        $this->open();
    }

    /**
     *
     */
    protected function open()
    {
        $this->tar = new PharData($this->archiveFileName, self::PHAR_FLAGS);
    }

    /**
     * @inheritDoc
     */
    public function getArchiveInformation()
    {
        $information = new ArchiveInformation();
        $stream_path_length = strlen('phar://'.$this->archiveFileName.'/');
        $information->compressedFilesSize = filesize($this->archiveFileName);
        $information->compressedFilesSize = filesize(/** @scrutinizer ignore-type */ $this->archiveFileName);
        /**
         * @var string $i
         * @var PharFileInfo $file
         */
        foreach (new RecursiveIteratorIterator($this->tar) as $i => $file) {
            $information->files[] = substr($file->getPathname(), $stream_path_length);
            $information->uncompressedFilesSize += $file->getSize();
        }
        $this->compressRatio = $information->compressedFilesSize > 0
            ? $information->uncompressedFilesSize / $information->compressedFilesSize
            : 0;
        $this->pureFilesNumber = count($information->files);
        return $information;
    }

    /**
     * @inheritDoc
     */
    public function getFileNames()
    {
        $files = [];

        $stream_path_length = strlen('phar://'.$this->archiveFileName.'/');
        foreach (new RecursiveIteratorIterator($this->tar) as $i => $file) {
            $files[] = substr($file->getPathname(), $stream_path_length);
        }

        return $files;
    }

    /**
     * @inheritDoc
     */
    public function isFileExists($fileName)
    {
        try {
            $this->tar->offsetGet($fileName);
            return true;
        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * @inheritDoc
     */
    public function getFileData($fileName)
    {
        /** @var \PharFileInfo $entry_info */
        $entry_info = $this->tar->offsetGet($fileName);
        return new ArchiveEntry(
            $fileName,
            ($this->compressRatio > 0 ? floor($entry_info->getSize() / $this->compressRatio) : 0), //$entry_info->getCompressedSize(),
            /** @scrutinizer ignore-type */ ($this->compressRatio > 0 ? floor($entry_info->getSize() / $this->compressRatio) : 0), //$entry_info->getCompressedSize(),
            $entry_info->getSize(),
            $entry_info->getMTime(),
            $entry_info->isCompressed());
    }

    /**
     * @inheritDoc
     */
    public function getFileContent($fileName)
    {
        return $this->tar->offsetGet($fileName)->getContent();
    }

    /**
     * @inheritDoc
     */
    public function getFileStream($fileName)
    {
        return fopen('phar://'.$this->archiveFileName . '/' . $fileName, 'rb');
    }

    /**
     * @inheritDoc
     */
    public function extractFiles($outputFolder, array $files)
    {
        $result = $this->tar->extractTo($outputFolder, $files, true);
        if ($result === false) {
            throw new ArchiveExtractionException('Error when extracting from '.$this->archiveFileName);
        }
        return count($files);
    }

    /**
     * @inheritDoc
     */
    public function extractArchive($outputFolder)
    {
        $result = $this->tar->extractTo($outputFolder, null, true);
        if ($result === false) {
            throw new ArchiveExtractionException('Error when extracting from '.$this->archiveFileName);
        }

        return $this->pureFilesNumber;
    }

    /**
     * @inheritDoc
     */
    public function deleteFiles(array $files)
    {
        $deleted = 0;

        foreach ($files as $i => $file) {
            if ($this->tar->delete($file))
                $deleted++;
        }

        $this->tar = null;
        $this->open();

        return $deleted;
    }

    /**
     * @inheritDoc
     */
    public function addFiles(array $files)
    {
        $added = 0;
        try {
            foreach ($files as $localName => $filename) {
                if (is_null($filename)) {
                    $this->tar->addEmptyDir($localName);
                } else {
                    $this->tar->addFile($filename, $localName);
                    $added++;
                }
            }
        } catch (Exception $e) {
            throw new ArchiveModificationException('Could not add file "'.$filename.'": '.$e->getMessage(), $e->getCode());
        }
        $this->tar = null;
        // reopen to refresh files list properly
        $this->open();
        return $added;
    }

    /**
     * @param array $files
     * @param string $archiveFileName
     * @param int $archiveFormat
     * @param int $compressionLevel
     * @param null $password

     * @param $fileProgressCallable
     * @return int
     * @throws ArchiveCreationException
     * @throws UnsupportedOperationException
     */
    public static function createArchive(
        array $files,
        $archiveFileName,
        $archiveFormat,
        $compressionLevel = self::COMPRESSION_AVERAGE,
        $password = null,
        $fileProgressCallable = null
    )
    {
        if ($password !== null) {

            throw new UnsupportedOperationException('One-file format ('.__CLASS__.') could not encrypt an archive');
        }

        if ($fileProgressCallable !== null && !is_callable($fileProgressCallable)) {
            throw new ArchiveCreationException('File progress callable is not callable');
        }

        if (preg_match('~^(.+)\.(tar\.(gz|bz2))$~i', $archiveFileName, $match)) {
            $ext = $match[2];
            $basename = $match[1];
        } else {
            $ext = pathinfo($archiveFileName, PATHINFO_EXTENSION);
            $basename = dirname($archiveFileName).'/'.basename($archiveFileName, '.'.$ext);
            $basename = dirname($archiveFileName).'/'.basename($archiveFileName, '.'./** @scrutinizer ignore-type */ $ext);
        }

        $compression = null;
        switch ($ext) {
            case 'tar.gz':
            case 'tgz':
                $compression = Phar::GZ;
                break;
            case 'tar.bz2':
            case 'tbz2':
                $compression = Phar::BZ2;
                break;
        }

        $destination_file = $basename.'.tar';
        // if compression used and there is .tar archive with that's name,
        // use temp file
        if ($compression !== null && file_exists($basename.'.tar')) {
            $temp_basename = tempnam(sys_get_temp_dir(), 'tar-archive');
            unlink($temp_basename);
            $destination_file = $temp_basename.'.tar';
        }

        $tar = new PharData(
            $destination_file,
            0, null, Phar::TAR
        );

        try {
            $current_file = 0;
            $total_files = count($files);

            foreach ($files as $localName => $filename) {
                if (is_null($filename)) {
                    if (!in_array($localName, ['/', ''], true)) {
                        if ($tar->addEmptyDir($localName) === false) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
                            throw new ArchiveCreationException('Error when adding directory '.$localName.' to archive');
                        }
                    }
                } else {
                    if ($tar->addFile($filename, $localName) === false) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
                        throw new ArchiveCreationException('Error when adding file '.$localName.' to archive');
                    }
                }
                if ($fileProgressCallable !== null) {
                    call_user_func_array($fileProgressCallable, [$current_file++, $total_files, $filename, $localName]);
                }
            }
        } catch (Exception $e) {
            throw new ArchiveCreationException('Error when creating archive: '.$e->getMessage(), $e->getCode(), $e);
        }

        switch ($compression) {
            case Phar::GZ:
                $tar->compress(Phar::GZ, $ext);
                break;
            case Phar::BZ2:
                $tar->compress(Phar::BZ2, $ext);
                break;
        }
        $tar = null;


        // if compression used and original .tar file exist, clean it
        if ($compression !== null && file_exists($destination_file)) {
            unlink($destination_file);
        }

        // it temp file was used, rename it to destination archive name
        if (isset($temp_basename)) {
            rename($temp_basename.'.'.$ext, $archiveFileName);
        }

        return count($files);
    }

    /**
     * @param string $inArchiveName
     * @param string $content
     * @return bool
     */
    public function addFileFromString($inArchiveName, $content)
    {
        $this->tar->addFromString($inArchiveName, $content);
        return true;
    }
}

wapmorgan / UnifiedArchive

Push — master ( b1d4f6...7824cd )

TarByPhar::canStream() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
