wapmorgan\UnifiedArchive\Drivers\NelexaZip

Complexity

Total Complexity

20

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getSupportedFormats()	0	4	1
A	setComment()	0	3	1
A	extractFiles()	0	2	1
A	getDescription()	0	3	1
A	getFileData()	0	11	1
A	getFileNames()	0	3	1
A	addFileFromString()	0	3	1
A	getComment()	0	3	1
A	getArchiveInformation()	0	14	3
A	getFileStream()	0	3	1
A	getFileContent()	0	3	1
A	checkFormatSupport()	0	8	1
A	isInstalled()	0	3	1
A	extractArchive()	0	2	1
A	__construct()	0	6	2
A	isFileExists()	0	3	1
A	getInstallationInstruction()	0	3	1

<?php

namespace wapmorgan\UnifiedArchive\Drivers;

use PhpZip\ZipFile;

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

use wapmorgan\UnifiedArchive\ArchiveEntry;
use wapmorgan\UnifiedArchive\ArchiveInformation;
use wapmorgan\UnifiedArchive\Exceptions\NonExistentArchiveFileException;
use wapmorgan\UnifiedArchive\Formats;

class NelexaZip extends BasicDriver
{
    const TYPE = self::TYPE_PURE_PHP;

    /**
     * @var ZipFile
     */
    protected $zip;

    /**
     * @var array
     */
    protected $files;

    /**
     * @inheritDoc
     * @throws \PhpZip\Exception\ZipException
     */
    public function __construct($archiveFileName, $format, $password = null)
    {
        $this->zip = new ZipFile();
        $this->zip->openFile($archiveFileName);
        if ($password !== null) {
            $this->zip->setReadPassword($password);
        }
    }

    /**
     * @inheritDoc
     */
    public function getArchiveInformation()
    {
        $this->files = [];
        $information = new ArchiveInformation();

        foreach ($this->zip->getAllInfo() as $info) {
            if ($info->isFolder())
                continue;

            $this->files[] = $information->files[] = str_replace('\\', '/', $info->getName());
            $information->compressedFilesSize += $info->getCompressedSize();
            $information->uncompressedFilesSize += $info->getSize();
        }
        return $information;
    }

    /**
     * @inheritDoc
     */
    public function getFileNames()
    {
        return $this->files;
    }

    /**
     * @inheritDoc
     */
    public function isFileExists($fileName)
    {
        return $this->zip->hasEntry($fileName);
    }

    /**
     * @inheritDoc
     */
    public function getFileData($fileName)
    {
        $info = $this->zip->getEntryInfo($fileName);
        return new ArchiveEntry(
            $fileName,
            $info->getCompressedSize(),
            $info->getSize(),
            $info->getMtime(),
            null,
            $info->getComment(),
            $info->getCrc()
        );
    }

    /**
     * @inheritDoc
     */
    public function getFileContent($fileName)
    {
        return $this->zip->getEntryContents($fileName);
    }

    /**
     * @inheritDoc
     * @throws NonExistentArchiveFileException
     */
    public function getFileStream($fileName)
    {
        return static::wrapStringInStream($this->getFileContent($fileName));
    }

    /**
     * @inheritDoc
     */
    public function extractFiles($outputFolder, array $files)
    {
        // TODO: Implement extractFiles() method.
    }

    /**
     * @inheritDoc
     */
    public function extractArchive($outputFolder)
    {
        // TODO: Implement extractArchive() method.
    }

    /**
     * @inheritDoc
     * @throws \PhpZip\Exception\ZipException
     */
    public function addFileFromString($inArchiveName, $content)
    {
        return $this->zip->addFromString($inArchiveName, $content);
    }

    public function getComment()
    {
        return $this->zip->getArchiveComment();
    }

    public function setComment($comment)
    {
        return $this->zip->setArchiveComment($comment);
    }

    public static function getSupportedFormats()
    {
        return [
            Formats::ZIP,
        ];
    }

    public static function checkFormatSupport($format)
    {
        return [
            BasicDriver::OPEN,
            BasicDriver::OPEN_ENCRYPTED,
            BasicDriver::EXTRACT_CONTENT,
            BasicDriver::APPEND,
            BasicDriver::DELETE,
        ];
    }

    public static function getDescription()
    {
        return 'nelexa/zip driver';
    }

    public static function isInstalled()
    {
        return class_exists('\\PhpZip\\ZipFile');
    }

    public static function getInstallationInstruction()
    {
        return 'install library [nelexa/zip]: `composer require nelexa/zip`';
    }
}