wapmorgan\UnifiedArchive\Formats\SevenZip

Complexity

Total Complexity

31

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Test Coverage

Coverage

34.52%

Importance

Changes	2
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	getFileContent()	0	4	1
A	canCreateArchive()	0	3	1
A	getFileResource()	0	8	1
A	createArchive()	0	14	4
A	addFiles()	0	15	4
A	getArchiveInformation()	0	11	3
A	deleteFiles()	0	11	3
A	extractFiles()	0	13	3
A	isFileExists()	0	3	1
A	canAddFiles()	0	4	2
A	canDeleteFiles()	0	3	1
A	getFileNames()	0	6	2
A	extractArchive()	0	8	2
A	getFileData()	0	5	1

<?php
namespace wapmorgan\UnifiedArchive\Formats;

use Exception;
use wapmorgan\UnifiedArchive\ArchiveEntry;
use wapmorgan\UnifiedArchive\ArchiveInformation;

class SevenZip extends BasicFormat
{
    /** @var Archive7z */
    protected $sevenZip;

    /**
     * BasicFormat constructor.
     *
     * @param string $archiveFileName
     *
     * @throws \Exception
     */
    public function __construct($archiveFileName)
    {
        try {
            $this->sevenZip = new Archive7z($archiveFileName, null, null);
        } catch (\Archive7z\Exception $e) {

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

            throw new Exception('Could not open 7Zip archive: '.$e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * @return ArchiveInformation
     */
    public function getArchiveInformation()
    {
        $information = new ArchiveInformation();
        foreach ($this->sevenZip->getEntries() as $entry) {
            $information->files[] = method_exists($entry, 'getUnixPath')
                ? $entry->getUnixPath()
                : str_replace('\\', '/', $entry->getPath());
            $information->compressedFilesSize += (int)$entry->getPackedSize();
            $information->uncompressedFilesSize += (int)$entry->getSize();
        }
        return $information;
    }

    /**
     * @return array
     */
    public function getFileNames()
    {
        $files = [];
        foreach ($this->sevenZip->getEntries() as $entry)
            $files[] = $entry->getPath();
        return $files;
    }

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

    /**
     * @param string $fileName
     *
     * @return ArchiveEntry|false
     */
    public function getFileData($fileName)
    {
        $entry = $this->sevenZip->getEntry($fileName);
        return new ArchiveEntry($fileName, $entry->getPackedSize(), $entry->getSize(),
            strtotime($entry->getModified()));
    }

    /**
     * @param string $fileName
     *
     * @return string|false
     */
    public function getFileContent($fileName)
    {
        $entry = $this->sevenZip->getEntry($fileName);
        return $entry->getContent();
    }

    /**
     * @param string $fileName
     *
     * @return bool|resource|string
     */
    public function getFileResource($fileName)
    {
        $resource = fopen('php://temp', 'r+');
        $entry = $this->sevenZip->getEntry($fileName);

        fwrite($resource, $entry->getContent());

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

        rewind($resource);

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

        return $resource;
    }

    /**
     * @param string $outputFolder
     * @param array  $files
     *
     * @return false|int
     * @throws \Archive7z\Exception
     * @throws \Exception
     */
    public function extractFiles($outputFolder, array $files)
    {
        $this->sevenZip->setOutputDirectory($outputFolder);
        $count = 0;
        try {

            foreach ($files as $file) {
                $this->sevenZip->extractEntry($file);
                $count++;
            }
            return $count;
        } catch (Exception $e) {
            throw new Exception('Could not extract archive: '.$e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * @param string $outputFolder
     *
     * @return false|bool
     * @throws \Exception
     */
    public function extractArchive($outputFolder)
    {
        $this->sevenZip->setOutputDirectory($outputFolder);
        try {
            $this->sevenZip->extract();
            return true;

The expression return true returns the type true which is incompatible with the return type mandated by wapmorgan\UnifiedArchive\Formats\BasicFormat::extractArchive() of false|integer.

        } catch (Exception $e) {
            throw new Exception('Could not extract archive: '.$e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * @param array $files
     *
     * @return false|int
     * @throws \Exception
     */
    public function deleteFiles(array $files)
    {
        $count = 0;
        try {
            foreach ($files as $file) {
                $this->sevenZip->delEntry($file);
                $count++;
            }
            return $count;
        } catch (Exception $e) {
            throw new Exception('Could not modify archive: '.$e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * @param array $files
     *
     * @return false|int
     * @throws \Exception
     */
    public function addFiles(array $files)
    {
        $added_files = 0;
        try {
            foreach ($files as $localName => $filename) {
                if (!is_null($filename)) {
                    $this->sevenZip->addEntry($filename);
                    $this->sevenZip->renameEntry($filename, $localName);
                    $added_files++;
                }
            }
        } catch (Exception $e) {
            throw new Exception('Could not modify archive: '.$e->getMessage(), $e->getCode(), $e);
        }
        return $added_files;
    }

    /**
     * @param array  $files
     * @param string $archiveFileName
     *
     * @return false|int
     * @throws \Archive7z\Exception
     * @throws \Exception
     */
    public static function createArchive(array $files, $archiveFileName) {
        $seven_zip = new Archive7z($archiveFileName);
        try {
            foreach ($files as $localName => $filename) {
                if ($filename !== null) {
                    $seven_zip->addEntry($filename, true);
                    $seven_zip->renameEntry($filename, $localName);
                }
            }
            unset($seven_zip);
        } catch (Exception $e) {
            throw new Exception('Could not create archive: '.$e->getMessage(), $e->getCode(), $e);
        }
        return count($files);
    }

    /**
     * @return bool
     * @throws \Archive7z\Exception
     */
    public static function canCreateArchive()
    {
        return static::canAddFiles();
    }

    /**
     * @return bool
     * @throws \Archive7z\Exception
     */
    public static function canAddFiles()
    {
        $version = Archive7z::getBinaryVersion();
        return $version !== false && version_compare('9.30', $version, '<=');
    }

    /**
     * @return bool
     */
    public static function canDeleteFiles()
    {
        return true;
    }
}