Quantum\Libraries\Archive\PharArchive

Complexity

Total Complexity

22

Size/Duplication

Total Lines	212
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	addFile()	0	10	2
A	deleteMultipleFilesUsingName()	0	8	1
A	deleteUsingName()	0	6	1
A	unset()	0	7	2
A	removeArchive()	0	9	2
A	addEmptyDir()	0	10	2
A	count()	0	6	1
A	renameUsingName()	0	6	1
A	__construct()	0	4	1
A	addMultipleFiles()	0	17	3
A	addFromString()	0	10	2
A	decompress()	0	7	2
A	extractTo()	0	12	2

<?php

/**
 * Quantum PHP Framework
 *
 * An open source software development framework for PHP
 *
 * @package Quantum
 * @author Arman Ag. <arman.ag@softberg.org>
 * @copyright Copyright (c) 2018 Softberg LLC (https://softberg.org)
 * @link http://quantum.softberg.org/
 * @since 2.8.0
 */

namespace Quantum\Libraries\Archive;

use Phar;

/**
 * Class ArchiveInterface
 * @package Quantum\Libraries\Archive
 */
class PharArchive implements ArchiveInterface
{

    /**
     * @var Phar|null
     */
    private static $instance = null;

The private property $instance is not used, and could be removed.

    private $newPhar;
    private $archiveName;

    /**
     * Phar constructor
     */
    public function __construct(string $archiveName)
    {
        // $this->newPhar = new Phar($archiveName);
        $this->archiveName = $archiveName;
    }

    // public function __destruct()
    // {
    //     // $newPhar->unlinkArchive($this->filename);

    //     $this->newPhar->unlinkArchive($this->archiveName);
    // }

    /**
     * @inheritDoc
     */
    public function removeArchive(): bool
    {
        try {
            // $newPhar = new Phar($this->archiveName);
            // $newPhar->decompress();
            return Phar::unlinkArchive($this->archiveName);
        } catch (\Throwable $th) {
            dump($th);
            return false;
        }
    }
    
    /**
     * @inheritDoc
     */
    public function decompress()
    {
        try {
            $this->newPhar->decompress();
        } catch (\Throwable $th) {
            dump($th);
            return false;
        }
    }
    
    /**
     * @inheritDoc
     */
    public function unset(string $fileName)

The parameter $fileName is not used and could be removed.

    {
        try {
            // unset($this->newPhar[$fileName]);
        } catch (\Throwable $th) {

catch (\Throwable $th) is not reachable.

            dump($th);
            return false;
        }
    }
    /**
     * @inheritDoc
     */
    public function addEmptyDir(string $newDirectory): bool
    {
        try {
            $newPhar = new Phar($this->archiveName);
            $newPhar->addEmptyDir($newDirectory);
            // dd($this->newPhar[$newDirectory]->isDir());
            return $newPhar[$newDirectory]->isDir();
        } catch (\Throwable $th) {
            dump($th);
            return false;
        }
    }

    /**
     * @inheritDoc
     */
    public function addFile(string $newFilePath, string $newFileName = ''): bool
    {
        try {
            $newPhar = new Phar($this->archiveName);
            $newPhar->addFile($newFilePath, $newFileName);
            // $this->newPhar->__destruct();
            return true;
        } catch (\Throwable $th) {
            // dump($th);
            return false;
        }
    }

    /**
     * @inheritDoc
     */
    public function addFromString(string $newFileName, string $newFileContent): bool
    {
        try {
            $newPhar = new Phar($this->archiveName);
            $newPhar->addFromString($newFileName, $newFileContent);
            // $this->newPhar->__destruct();
            return true;
        } catch (\Throwable $th) {
            // dump($th);
            return false;
        }
    }

    /**
     * @inheritDoc
     */
    public function deleteUsingName(string $fileOrDirName): bool
    {
        // if ($this->pharArchive->open($archiveName) === TRUE) {
        //     $this->pharArchive->deleteName($fileOrDirName);
        // $this->newPhar->__destruct();
        return true;
        // } else {
        //     return false;
        // }
    }

    /**
     * @inheritDoc
     */
    public function extractTo(string $pathToExtract, $files = ''): bool
    {

        try {
            $newPhar = new Phar($this->archiveName);
            $newPhar->extractTo($pathToExtract, $files);
            // $this->newPhar->__destruct();
            return true;
        } catch (\Throwable $th) {
            // dump($th);

            return false;
        }
    }

    /**
     * @inheritDoc
     */
    public function count(): int
    {
        $newPhar = new Phar($this->archiveName);
        $pharCount = $newPhar->count();
        // $this->newPhar->__destruct();
        return $pharCount;
    }

    /**
     * @inheritDoc
     */
    public function renameUsingName(string $currentName, string $newName): bool
    {
        // if ($this->pharArchive->open($archiveName) === TRUE) {
        //     $this->pharArchive->renameName($currentName, $newName);
        // $this->newPhar->__destruct();
        return true;
        // } else {
        //     return false;
        // }
    }

    /**
     * @inheritDoc
     */
    public function addMultipleFiles(array $fileNames): bool
    {


        try {
            // dd($fileNames);
            $newPhar = new Phar($this->archiveName);
            foreach ($fileNames as $fileNmae => $filePath) {
                // dd($fileNmae , $filePath);
                // $this->pharArchive->addFile($filePath, $fileNmae);
                $newPhar->addFile($filePath, $fileNmae);
            }
            // $this->newPhar->__destruct();
            return true;
        } catch (\Throwable $th) {
            // dump($th);
            return false;
        }
        // if ($this->pharArchive->open($archiveName) === TRUE) {
            // $this->newPhar->__destruct();
        // return true;
        // } else {
        //     return false;
        // }
    }

    /**
     * @inheritDoc
     */
    public function deleteMultipleFilesUsingName(array $fileNames): bool
    {
        // if ($this->pharArchive->open($archiveName) === TRUE) {
        //     foreach ($fileNames as $fileNmae => $filePath) {
        //         $this->pharArchive->addFile($filePath, $fileNmae);
        //     }
        // $this->newPhar->__destruct();
        return true;
        // } else {
        //     return false;
        // }
    }
}