ꦫꦣꦺꦤ꧀ꦄꦤ꧀ꦠꦱꦺꦤ

PATH: home / thebhoeo / .trash / backwpup / vendor / inpsyde / backwpup-archiver / src

<?php

/*
 * This file is part of the BackWPup Archiver package.
 *
 * (c) Inpsyde <hello@inpsyde.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Inpsyde\BackWPup\Archiver;

use Inpsyde\Assert\Assert;
use InvalidArgumentException;
use SplFileInfo;
use ZipArchive;

/**
 * Class Zip
 *
 * @internal
 *
 * @author Guido Scialfa <dev@guidoscialfa.com>
 */
class Zip implements ArchiveFileOperator, Closable
{
    /**
     * @var ZipArchive
     */
    private $zipArchive;

/**
     * @var string
     */
    private $fileName;

/**
     * @var bool
     */
    private $isOpen = false;

/**
     * Zip constructor
     * @param ZipArchive $zipArchive
     * @param $fileName
     * @throws InvalidArgumentException If file name isn't a valid path
     */
    public function __construct(ZipArchive $zipArchive, $fileName)
    {
        // TODO Improve assert for Filename, check traversal path etc...
        Assert::path($fileName);

$this->zipArchive = $zipArchive;
        $this->fileName = $fileName;
    }

/**
     * Create the Archive file
     *
     * @return void
     * @throws ArchiveException If the archive cannot be opened
     */
    public function create()
    {
        !$this->isOpen and $this->openWithFlag(ZipArchive::CREATE);
    }

/**
     * Open the Archive for Read
     *
     * @return void
     * @throws ArchiveException If the archive cannot be opened
     */
    public function open()
    {
        !$this->isOpen and $this->openWithFlag(ZipArchive::ER_READ);
    }

/**
     * Close the Archive File
     *
     * @return void
     */
    public function close()
    {
        $this->isOpen and $this->zipArchive->close();

$this->isOpen = false;
    }

/**
     * @inheritDoc
     */
    public function isValid()
    {
        try {
            $this->open();
        } catch (ArchiveException $exc) {
            return false;
        }

return ZipArchive::ER_OK === $this->zipArchive->status;
    }

/**
     * @inheritDoc
     */
    public function extractTo($destination)
    {
        Assert::path($destination);

$this->open();

$extracted = $this->zipArchive->extractTo($destination);

if (!$extracted) {
            throw ArchiveException::becauseArchiveCannotBeExtracted($this->fileName);
        }
    }

/**
     * @inheritDoc
     */
    public function extractFileByIndex($index, $destination)
    {
        Assert::greaterThanEq($index, 0);
        Assert::path($destination);

$this->open();

$fileName = $this->zipArchive->getNameIndex($index);

if (!$fileName) {
            throw ArchiveException::forInvalidFileIndex($index);
        }

$extracted = $this->zipArchive->extractTo($destination, $fileName);

if (!$extracted) {
            throw ArchiveException::becauseFileCannotBeExtracted($fileName);
        }
    }

/**
     * @inheritDoc
     */
    public function delete()
    {
        $this->close();

// TODO Would be better an abstraction?
        file_exists($this->fileName) and unlink($this->fileName);
    }

/**
     * @inheritDoc
     */
    public function content()
    {
        $this->open();

$list = [];
        $numEntries = $this->zipArchive->numFiles;

for ($count = 0; $count < $numEntries; ++$count) {
            $item = $this->zipArchive->getNameIndex($count);
            if (!$item) {
                throw ArchiveException::forContentUnretrievable();
            }

$list[] = $item;
        }

return $list;
    }

/**
     * @inheritDoc
     */
    public function count()
    {
        $this->open();

return $this->zipArchive->numFiles;
    }

/**
     * @inheritDoc
     */
    public function add(SplFileInfo $file)
    {
        $fileName = $file->getPathname();

if (!$file->isReadable()) {
            throw FileException::becauseFileIsNotReadable($fileName);
        }

$this->create();

$added = $this->zipArchive->addFile($fileName);

if (!$added) {
            throw ArchiveException::forFileCannotBeAddBecauseInternalError($fileName);
        }
    }

/**
     * @inheritDoc
     */
    public function fetch(SplFileInfo $file)
    {
        $this->open();

$fileName = $file->getPathname();
        $temDir = rtrim(sys_get_temp_dir(), DIRECTORY_SEPARATOR);
        $filePath = "{$temDir}/{$fileName}";
        $extracted = $this->zipArchive->extractTo($temDir, $fileName);

if (!$extracted) {
            throw ArchiveException::becauseFileCannotBeExtracted($fileName);
        }

return new SplFileInfo($filePath);
    }

/**
     * @inheritDoc
     */
    public function exists(SplFileInfo $file)
    {
        $this->open();

$fileName = $file->getFilename();
        $index = $this->zipArchive->locateName($fileName);

return $index !== false;
    }

/**
     * @inheritDoc
     */
    public function replace(SplFileInfo $file)
    {
        $this->remove($file);
        $this->add($file);
    }

/**
     * @inheritDoc
     */
    public function remove(SplFileInfo $file)
    {
        $this->open();

$fileName = $file->getFilename();
        $deleted = $this->zipArchive->deleteName($fileName);

if (!$deleted) {
            throw ArchiveException::becauseFileCannotBeDeleted($fileName);
        }
    }

/**
     * @inheritDoc
     */
    public function fileNameByIndex($index)
    {
        Assert::greaterThanEq($index, 0);

$fileName = $this->zipArchive->getNameIndex($index);

if (!$fileName) {
            throw ArchiveException::forInvalidFileIndex($index);
        }

return $fileName;
    }

/**
     * Open a Zip File With the Specified Flag
     *
     * @param int $flag
     * @return void
     * @throws ArchiveException
     */
    private function openWithFlag($flag)
    {
        $opened = $this->zipArchive->open($this->fileName, $flag);

if ($opened !== true) {
            throw ArchiveException::becauseArchiveCannotBeOpened($opened);
        }

$this->isOpen = true;
    }
}

[-] Archive.php [edit]
[-] Closable.php [edit]
[-] CurrentExtractInfo.php [edit]
[-] FallBackZip.php [edit]
[-] Factory.php [edit]
[-] Zip.php [edit]
[-] ArchiveQueryable.php [edit]
[-] ArchiveFileOperator.php [edit]
[-] Extractor.php [edit]
[+] ..
[-] FileException.php [edit]
[-] ArchiveException.php [edit]