wapmorgan\UnifiedArchive\Formats\Tar

Complexity

Total Complexity

103

Size/Duplication

Total Lines	612
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	checkRequirements()	0	5	3
C	detectArchiveType()	0	37	13
A	isFileExists()	0	10	3
A	createArchive()	0	11	3
A	extractFiles()	0	13	3
A	getFileData()	0	24	4
A	getFileNamesForPear()	0	14	3
A	getArchiveInformation()	0	30	6
C	createArchiveForPear()	0	40	12
B	addFiles()	0	36	9
A	getFileResource()	0	13	3
A	__destruct()	0	3	1
B	open()	0	42	10
A	deleteFiles()	0	16	4
A	extractArchive()	0	13	3
A	getFileNames()	0	5	2
A	getFileNamesForPhar()	0	10	2
A	getFileContent()	0	10	3
C	createArchiveForPhar()	0	42	12
A	__construct()	0	9	2
A	canDeleteFiles()	0	4	1
A	canAddFiles()	0	3	1

<?php
namespace wapmorgan\UnifiedArchive\Formats;

use Archive_Tar;
use Exception;
use FilesystemIterator;
use Phar;
use PharData;
use RecursiveIteratorIterator;
use wapmorgan\UnifiedArchive\ArchiveEntry;
use wapmorgan\UnifiedArchive\ArchiveInformation;
use wapmorgan\UnifiedArchive\LzwStreamWrapper;
use wapmorgan\UnifiedArchive\UnsupportedOperationException;

/**
 * Tar format handler
 * @package wapmorgan\UnifiedArchive\Formats
 */
class Tar extends BasicFormat
{
    const TAR = 'tar';
    const TAR_GZIP = 'tgz';
    const TAR_BZIP = 'tbz2';
    const TAR_LZMA = 'txz';
    const TAR_LZW = 'tar.z';

    /** @var bool */
    static protected $enabledPearTar;

    /** @var bool */
    static protected $enabledPharData;
    /**
     * Checks system configuration for available Tar-manipulation libraries
     */
    protected static function checkRequirements()
    {
        if (self::$enabledPharData === null || self::$enabledPearTar === null) {

The condition self::enabledPearTar === null is always false.

            self::$enabledPearTar = class_exists('\Archive_Tar');
            self::$enabledPharData = class_exists('\PharData');
        }
    }

    /**
     * Checks whether archive can be opened with current system configuration
     * @param $archiveFileName
     * @return boolean
     */
//    public static function canOpenArchive($archiveFileName)
//    {
//        self::checkRequirements();
//
//        $type = self::detectArchiveType($archiveFileName);
//        if ($type !== false) {
//            return self::canOpenType($type);
//        }
//
//        return false;
//    }

    /**
     * Detect archive type by its filename or content.
     * @param $archiveFileName
     * @param bool $contentCheck
     * @return string|boolean One of TarArchive type constants OR false if type is not detected
     */
    public static function detectArchiveType($archiveFileName, $contentCheck = true)
    {
        // by file name
        if (preg_match('~\.(?<ext>tar|tgz|tbz2|txz|tar\.(gz|bz2|xz|z))$~', strtolower($archiveFileName), $match)) {
            switch ($match['ext']) {
                case 'tar':
                    return self::TAR;

                case 'tgz':
                case 'tar.gz':
                    return self::TAR_GZIP;

                case 'tbz2':
                case 'tar.bz2':
                    return self::TAR_BZIP;

                case 'txz':
                case 'tar.xz':
                    return self::TAR_LZMA;

                case 'tar.z':
                    return self::TAR_LZW;
            }
        }

        // by content
        if ($contentCheck) {
            $mime_type = mime_content_type($archiveFileName);
            switch ($mime_type) {
                case 'application/x-tar':
                    return self::TAR;
                case 'application/x-gtar':
                    return self::TAR_GZIP;
            }
        }

        return false;
    }

    /**
     * Checks whether specific archive type can be opened with current system configuration
     * @param $type
     * @return boolean
     */
//    public static function canOpenType($type)
//    {
//        self::checkRequirements();
//        switch ($type) {
//            case self::TAR:
//                return self::$enabledPearTar || self::$enabledPharData;
//
//            case self::TAR_GZIP:
//                return (self::$enabledPearTar || self::$enabledPharData) && extension_loaded('zlib');
//
//            case self::TAR_BZIP:
//                return (self::$enabledPearTar || self::$enabledPharData) && extension_loaded('bz2');
//
//
//            case self::TAR_LZMA:
//                return self::$enabledPearTar && extension_loaded('lzma2');
//
//            case self::TAR_LZW:
//                return self::$enabledPearTar && LzwStreamWrapper::isBinaryAvailable();
//        }
//
//        return false;
//    }

    /**
     * @param array $files
     * @param string $archiveFileName
     * @return false|int
     * @throws Exception
     */
    public static function createArchive(array $files, $archiveFileName)
    {
        static::checkRequirements();

        if (static::$enabledPharData)
            return static::createArchiveForPhar($files, $archiveFileName);

The expression return static::createArchiveForPhar($files, $archiveFileName) returns the type boolean which is incompatible with the documented return type false|integer.

        if (static::$enabledPearTar)
            return static::createArchiveForPear($files, $archiveFileName);

        throw new Exception('Archive_Tar nor PharData not available');
    }

    /**
     * Creates an archive via Pear library
     * @param array $files
     * @param $archiveFileName
     * @return bool|int
     * @throws Exception
     */
    protected static function createArchiveForPear(array $files, $archiveFileName)
    {
        $compression = null;
        switch (strtolower(pathinfo($archiveFileName, PATHINFO_EXTENSION))) {
            case 'gz':
            case 'tgz':
                $compression = 'gz';
                break;
            case 'bz2':
            case 'tbz2':
                $compression = 'bz2';
                break;
            case 'xz':
                $compression = 'lzma2';
                break;
            case 'z':
                $tar_aname = 'compress.lzw://' . $archiveFileName;
                break;
        }

        if (isset($tar_aname))
            $tar = new Archive_Tar($tar_aname, $compression);
        else
            $tar = new Archive_Tar($archiveFileName, $compression);

        foreach ($files  as $localName => $filename) {
            $remove_dir = dirname($filename);
            $add_dir = dirname($localName);

            if (is_null($filename)) {
                if ($tar->addString($localName, '') === false)
                    throw new Exception('Error when adding directory '.$localName.' to archive');
            } else {
                if ($tar->addModify($filename, $add_dir, $remove_dir) === false)
                    throw new Exception('Error when adding file '.$filename.' to archive');
            }
        }
        $tar = null;

The assignment to $tar is dead and can be removed.

        return count($files);
    }

    /**
     * Creates an archive via Phar library
     * @param array $files
     * @param $archiveFileName
     * @return bool
     */
    protected static function createArchiveForPhar(array $files, $archiveFileName)
    {
        if (preg_match('~^(.+)\.(tar\.(gz|bz2))$~i', $archiveFileName, $match)) {
            $ext = $match[2];
            $basename = $match[1];
        } else {
            $ext = pathinfo($archiveFileName, PATHINFO_EXTENSION);
            $basename = dirname($archiveFileName).'/'.basename($archiveFileName, '.'.$ext);
        }
        $tar = new PharData($basename.'.tar', 0, null, Phar::TAR);

        try {
            foreach ($files as $localName => $filename) {
                if (is_null($filename)) {
                    if (!in_array($localName, ['/', ''], true)) {
                        if ($tar->addEmptyDir($localName) === false) {

Are you sure the usage of $tar->addEmptyDir($localName) targeting Phar::addEmptyDir() seems to always return null.

                            return false;
                        }
                    }
                } else {
                    if ($tar->addFile($filename, $localName) === false) {

Are you sure the usage of $tar->addFile($filename, $localName) targeting Phar::addFile() seems to always return null.

                        return false;
                    }
                }
            }
        } catch (Exception $e) {
            return false;
        }

        switch (strtolower(pathinfo($archiveFileName, PATHINFO_EXTENSION))) {
            case 'gz':
            case 'tgz':
                $tar->compress(Phar::GZ, $ext);
                break;
            case 'bz2':
            case 'tbz2':
                $tar->compress(Phar::BZ2, $ext);
                break;
        }
        $tar = null;

The assignment to $tar is dead and can be removed.

        return count($files);

The expression return count($files) returns the type integer which is incompatible with the documented return type boolean.

    }

    /** @var string Full path to archive */
    protected $archiveFileName;

    /** @var string Full path to archive */
    protected $archiveType;

    /** @var Archive_Tar|PharData */
    protected $tar;

    /** @var float Overall compression ratio of Tar archive when Archive_Tar is used */
    protected $pearCompressionRatio;

    /** @var array<string, integer> List of files and their index in listContent() result */
    protected $pearFilesIndex;

    /** @var int Flags for iterator */
    const PHAR_FLAGS = FilesystemIterator::UNIX_PATHS;

    /**
     * Tar format constructor.
     *
     * @param string $archiveFileName
     * @throws \Exception
     */
    public function __construct($archiveFileName)
    {
        static::checkRequirements();

        $this->archiveFileName = realpath($archiveFileName);
        $this->archiveType = static::detectArchiveType($this->archiveFileName);

It seems like static::detectArchiveType($this->archiveFileName) can also be of type false. However, the property $archiveType is declared as type string. Maybe add an additional type check?

        if ($this->archiveType === false)
            throw new \Exception('Could not detect type for archive '.$this->archiveFileName);
        $this->open($this->archiveType);
    }

    /**
     * Tar destructor
     */
    public function __destruct()
    {
        $this->tar = null;
    }

    /**
     * @param $archiveType
     * @throws Exception
     */
    protected function open($archiveType)
    {
        switch ($archiveType) {
            case self::TAR_GZIP:
                if (self::$enabledPharData) {
                    $this->tar = new PharData($this->archiveFileName, self::PHAR_FLAGS);
                } else {
                    $this->tar = new Archive_Tar($this->archiveFileName, 'gz');
                }
                break;

            case self::TAR_BZIP:
                if (self::$enabledPharData) {
                    $this->tar = new PharData($this->archiveFileName, self::PHAR_FLAGS);
                } else {
                    $this->tar = new Archive_Tar($this->archiveFileName, 'bz2');
                }
                break;

            case self::TAR_LZMA:
                if (!self::$enabledPharData) {
                    throw new Exception('Archive_Tar not available');
                }
                $this->tar = new Archive_Tar($this->archiveFileName, 'lzma2');
                break;

            case self::TAR_LZW:
                if (!self::$enabledPharData) {
                    throw new Exception('Archive_Tar not available');
                }

                LzwStreamWrapper::registerWrapper();
                $this->tar = new Archive_Tar('compress.lzw://' . $this->archiveFileName);
                break;

            default:
                if (self::$enabledPharData) {
                    $this->tar = new PharData($this->archiveFileName, self::PHAR_FLAGS);
                } else {
                    $this->tar = new Archive_Tar($this->archiveFileName);
                }
                break;
        }
    }

    /**
     * @return ArchiveInformation
     */
    public function getArchiveInformation()
    {
        $information = new ArchiveInformation();
        if ($this->tar instanceof Archive_Tar) {
            $this->pearFilesIndex = [];

            foreach ($this->tar->listContent() as $i => $file) {
                // BUG workaround: http://pear.php.net/bugs/bug.php?id=20275
                if ($file['filename'] === 'pax_global_header') {
                    continue;
                }
                $information->files[] = $file['filename'];
                $information->uncompressedFilesSize += $file['size'];
                $this->pearFilesIndex[$file['filename']] = $i;
            }

            $information->uncompressedFilesSize = filesize($this->archiveFileName);
            $this->pearCompressionRatio = $information->uncompressedFilesSize != 0
                ? ceil($information->compressedFilesSize / $information->uncompressedFilesSize)
                : 1;
        } else {
            $stream_path_length = strlen('phar://'.$this->archiveFileName.'/');
            foreach (new RecursiveIteratorIterator($this->tar) as $i => $file) {
                $information->files[] = substr($file->getPathname(), $stream_path_length);
                $information->compressedFilesSize += $file->getCompressedSize();
                $information->uncompressedFilesSize += filesize($file->getPathname());
            }
        }

        return $information;
    }

    /**
     * @return array
     */
    public function getFileNames()
    {
        return $this->tar instanceof Archive_Tar
            ? $this->getFileNamesForPear()
            : $this->getFileNamesForPhar();
    }

    /**
     * @param string $fileName
     * @return bool
     */
    public function isFileExists($fileName)
    {
        if ($this->tar instanceof Archive_Tar)
            return isset($this->pearFilesIndex[$fileName]);

        try {
            $this->tar->offsetGet($fileName);
            return true;
        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * @param string $fileName
     * @return ArchiveEntry|false
     * @throws Exception
     */
    public function getFileData($fileName)
    {
        if ($this->tar instanceof Archive_Tar) {
            if (!isset($this->pearFilesIndex[$fileName]))
                throw new Exception('File '.$fileName.' is not found in archive files list');

            $index = $this->pearFilesIndex[$fileName];

            $files_list = $this->tar->listContent();
            if (!isset($files_list[$index]))
                throw new Exception('File '.$fileName.' is not found in Tar archive');

            $data = $files_list[$index];
            unset($files_list);

            return new ArchiveEntry($fileName, $data['size'] / $this->pearCompressionRatio,
                $data['size'], $data['mtime'], in_array(strtolower(pathinfo($this->archiveFileName,
                    PATHINFO_EXTENSION)), array('gz', 'bz2', 'xz', 'Z')));
        }

        /** @var \PharFileInfo $entry_info */
        $entry_info = $this->tar->offsetGet($fileName);
        return new ArchiveEntry($fileName, $entry_info->getSize(), filesize($entry_info->getPathname()),
            0, $entry_info->isCompressed());
    }

    /**
     * @param string $fileName
     * @return string|false
     * @throws Exception
     */
    public function getFileContent($fileName)
    {
        if ($this->tar instanceof Archive_Tar) {
            if (!isset($this->pearFilesIndex[$fileName]))
                throw new Exception('File '.$fileName.' is not found in archive files list');

            return $this->tar->extractInString($fileName);

The expression return $this->tar->extractInString($fileName) returns the type a which is incompatible with the documented return type false|string.

        }

        return $this->tar->offsetGet($fileName)->getContent();
    }

    /**
     * @param string $fileName
     * @return bool|resource|string
     * @throws Exception
     */
    public function getFileResource($fileName)
    {
        $resource = fopen('php://temp', 'r+');
        if ($this->tar instanceof Archive_Tar) {
            if (!isset($this->pearFilesIndex[$fileName]))
                throw new Exception('File '.$fileName.' is not found in archive files list');

            fwrite($resource, $this->tar->extractInString($fileName));

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?

$this->tar->extractInString($fileName) of type a is incompatible with the type string expected by parameter $string of fwrite().

        } else
            fwrite($resource, $this->tar->offsetGet($fileName)->getContent());

        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 Exception
     */
    public function extractFiles($outputFolder, array $files)
    {
        if ($this->tar instanceof Archive_Tar) {
            $result = $this->tar->extractList($files, $outputFolder);
        } else {
            $result = $this->tar->extractTo($outputFolder, $files, true);
        }

        if ($result === false) {
            throw new Exception('Error when extracting from '.$this->archiveFileName);
        }

        return count($files);
    }

    /**
     * @param string $outputFolder
     * @return false|int
     * @throws Exception
     */
    public function extractArchive($outputFolder)
    {
        if ($this->tar instanceof Archive_Tar) {
            $result = $this->tar->extract($outputFolder);
        } else {
            $result = $this->tar->extractTo($outputFolder, null, true);
        }

        if ($result === false) {
            throw new Exception('Error when extracting from '.$this->archiveFileName);
        }

        return 1;
    }

    /**
     * @param array $files
     * @return false|int
     * @throws UnsupportedOperationException
     * @throws Exception
     */
    public function deleteFiles(array $files)
    {
        if ($this->tar instanceof Archive_Tar)
            throw new UnsupportedOperationException();

        $deleted = 0;

        foreach ($files as $i => $file) {
            if ($this->tar->delete($file))
                $deleted++;
        }

        $this->tar = null;
        $this->open($this->archiveType);

        return $deleted;
    }

    /**
     * @param array $files
     * @return false|int
     * @throws Exception
     */
    public function addFiles(array $files)
    {
        $added = 0;

        if ($this->tar instanceof Archive_Tar) {
            foreach ($files as $localName => $filename) {
                $remove_dir = dirname($filename);
                $add_dir = dirname($localName);
                if (is_null($filename)) {
                    if ($this->tar->addString($localName, "") === false)
                        return false;
                } else {
                    if ($this->tar->addModify($filename, $add_dir, $remove_dir) === false)
                        return false;
                    $added++;
                }
            }
        } else {
            try {
                foreach ($files as $localName => $filename) {
                    if (is_null($filename)) {
                        $this->tar->addEmptyDir($localName);
                    } else {
                        $this->tar->addFile($filename, $localName);
                        $added++;
                    }
                }
            } catch (Exception $e) {
                return false;
            }
            $this->tar = null;
            // reopen to refresh files list properly
            $this->open($this->archiveType);
        }

        return $added;
    }

    /**
     * @return array
     */
    protected function getFileNamesForPear()
    {
        $files = [];

        $Content = $this->tar->listContent();

The method listContent() does not exist on PharData.

        foreach ($Content as $i => $file) {
            // BUG workaround: http://pear.php.net/bugs/bug.php?id=20275
            if ($file['filename'] === 'pax_global_header') {
                continue;
            }
            $files[] = $file['filename'];
        }

        return $files;
    }

    /**
     * @return array
     */
    protected function getFileNamesForPhar()
    {
        $files = [];

        $stream_path_length = strlen('phar://'.$this->archiveFileName.'/');
        foreach (new RecursiveIteratorIterator($this->tar) as $i => $file) {

It seems like $this->tar can also be of type Archive_Tar; however, parameter $iterator of RecursiveIteratorIterator::__construct() does only seem to accept Traversable, maybe add an additional type check?

            $files[] = substr($file->getPathname(), $stream_path_length);
        }

        return $files;
    }

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

    /**
     * @return bool
     */
    public static function canDeleteFiles()
    {
        static::checkRequirements();
        return self::$enabledPharData;
    }
}