PharArchive::renameUsingName() - Code Metrics - Inspection of "Added ZipArchive class" - softberg/quantum-php-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#131)

unknown
created 2023-03-08 09:47 UTC
PharArchive::renameUsingName() A

↳ Parent: PharArchive
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	6
rs	10
<?php

/**
 * Quantum PHP Framework
 *
 * An open source software development framework for PHP
 *
 * @package Quantum
 * @author Arman Ag. <[email protected]>
 * @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;


    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)
    public function unset(/** @scrutinizer ignore-unused */ string $fileName)
    {
        try {
            // unset($this->newPhar[$fileName]);
        } catch (\Throwable $th) {
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            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;
        // }
    }
}

softberg / quantum-php-core

Pull Request — master (#131)

PharArchive::renameUsingName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
