Rar::checkFormatSupport() - Code Metrics - Inspection of "Update docs." - wapmorgan/UnifiedArchive - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3fc76b...c4daa3 )

by f

created 2023-06-23 06:11 UTC

Rar::checkFormatSupport() A

↳ Parent: Rar

Complexity

Conditions	3
Paths	3

Size

Total Lines	13
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
cc	3
eloc	10
c	0
b	0
f	0
nc	3
nop	1
dl	0
loc	13
rs	9.9332
ccs	0
cts	4
cp	0
crap	12

<?php
namespace wapmorgan\UnifiedArchive\Drivers;

use Exception;
use wapmorgan\UnifiedArchive\Abilities;
use wapmorgan\UnifiedArchive\ArchiveEntry;
use wapmorgan\UnifiedArchive\ArchiveInformation;
use wapmorgan\UnifiedArchive\Drivers\Basic\BasicExtensionDriver;
use wapmorgan\UnifiedArchive\Formats;

class Rar extends BasicExtensionDriver
{
    const NONE_RAR_COMPRESSION = 48;
    const EXTENSION_NAME = 'rar';

    /** @var \RarArchive */
    protected $rar;

    /**
     * @inheritDoc
     */
    public static function getDescription()
    {
        return 'adapter for ext-rar' . (self::isInstalled() ? ' (' . phpversion('rar') . ')' : null);
    }

    /**
     * @inheritDoc
     */
    public static function getInstallationInstruction()
    {
        return 'install [rar] extension.' . "\n" . 'Can be installed with pecl: `pecl install rar`';
    }

    /**
     * @return array
     */
    public static function getFormats()
    {
        return [
            Formats::RAR,
        ];
    }

    /**
     * @param $format
     * @return array
     */
    public static function getFormatAbilities($format)
    {
        if (!static::isInstalled()) {
            return [];
        }
        switch ($format) {
            case Formats::RAR:
                return [
                    Abilities::OPEN,
                    Abilities::OPEN_ENCRYPTED,
                    Abilities::OPEN_VOLUMED,
                    Abilities::EXTRACT_CONTENT,
                    Abilities::STREAM_CONTENT,
                ];
        }
    }

    /**
     * @inheritDoc
     */
    public function __construct($archiveFileName, $format, $password = null)
    {
        parent::__construct($archiveFileName, $format);
        \RarException::setUsingExceptions(true);
        $this->open($archiveFileName, $password);
    }

    /**
     * @param $archiveFileName
     * @param $password
     * @throws Exception
     */
    protected function open($archiveFileName, $password)
    {
        $this->rar = \RarArchive::open($archiveFileName, $password, function ($vol) {
        $this->rar = \RarArchive::open($archiveFileName, $password, function (/** @scrutinizer ignore-unused */ $vol) {
            throw new Exception('Could not open volumed Rar archive');
        });
        $this->rar->setAllowBroken(true);
        if ($this->rar === false) {
            throw new Exception('Could not open Rar archive');
        }
    }

    /**
     * Rar format destructor
     */
    public function __destruct()
    {
        $this->rar->close();
    }

    /**
     * @return ArchiveInformation
     */
    public function getArchiveInformation()
    {
        $information = new ArchiveInformation();
        foreach ($this->rar->getEntries() as $i => $entry) {
            if ($entry->isDirectory()) continue;
            $information->files[] = $entry->getName();
            $information->compressedFilesSize += $entry->getPackedSize();
            $information->uncompressedFilesSize += $entry->getUnpackedSize();
        }
        return $information;
    }

    /**
     * @return string|null
     */
    public function getComment()
    {
        return $this->rar->getComment();
    }

    /**
     * @return array
     */
    public function getFileNames()
    {
        $files = [];
        foreach ($this->rar->getEntries() as $i => $entry) {
            if ($entry->isDirectory()) continue;
            $files[] = $entry->getName();
        }
        return $files;
    }

    /**
     * @param string $fileName
     *
     * @return bool
     */
    public function isFileExists($fileName)
    {
        return $this->rar->getEntry($fileName) !== false;
    }

    /**
     * @param string $fileName
     *
     * @return ArchiveEntry|false
     */
    public function getFileData($fileName)
    {
        $entry = $this->rar->getEntry($fileName);
        return new ArchiveEntry($fileName, $entry->getPackedSize(), $entry->getUnpackedSize(),
            strtotime($entry->getFileTime()), $entry->getMethod() != self::NONE_RAR_COMPRESSION);
    }

    /**
     * @param string $fileName
     *
     * @return string|false
     */
    public function getFileContent($fileName)
    {
        $entry = $this->rar->getEntry($fileName);
        if ($entry->isDirectory()) return false;
        return stream_get_contents($entry->getStream());
    }

    /**
     * @param string $fileName
     *
     * @return bool|resource|string
     */
    public function getFileStream($fileName)
    {
        $entry = $this->rar->getEntry($fileName);
        if ($entry->isDirectory()) return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        return $entry->getStream();
    }

    /**
     * @param string $outputFolder
     * @param array  $files
     *
     * @return false|int
     */
    public function extractFiles($outputFolder, array $files)
    {
        $count = 0;
        foreach ($files as $file) {
            if ($this->rar->getEntry($file)->extract($outputFolder)) {
                $count++;
            }
        }
        return $count;
    }

    /**
     * @param string $outputFolder
     *
     * @return false|resource
     */
    public function extractArchive($outputFolder)
    {
        return $this->extractFiles($outputFolder, $this->getFileNames());

    }
}


wapmorgan / UnifiedArchive

Push — master ( 3fc76b...c4daa3 )

Rar::checkFormatSupport() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like