ZipEntry::create() - Code Metrics - Inspection of "Merge branch 'hotfix/3.2.2'" - Ne-Lexa/php-zip - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( d305ab...074443 )

by Alexey
created 2020-02-04 08:41 UTC
ZipEntry::create() A

↳ Parent: ZipEntry
Complexity

Conditions	1
Paths	1
Size

Total Lines	37
Code Lines	18
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	19
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
cc	1
eloc	18
nc	1
nop	16
dl	0
loc	37
ccs	19
cts	19
cp	1
crap	1
rs	9.6666
c	1
b	0
f	1
How to fix Many Parameters

<?php

/** @noinspection PhpUsageOfSilenceOperatorInspection */

namespace PhpZip\Model;

use PhpZip\Constants\DosAttrs;
use PhpZip\Constants\DosCodePage;
use PhpZip\Constants\GeneralPurposeBitFlag;
use PhpZip\Constants\UnixStat;
use PhpZip\Constants\ZipCompressionLevel;
use PhpZip\Constants\ZipCompressionMethod;
use PhpZip\Constants\ZipConstants;
use PhpZip\Constants\ZipEncryptionMethod;
use PhpZip\Constants\ZipPlatform;
use PhpZip\Constants\ZipVersion;
use PhpZip\Exception\InvalidArgumentException;
use PhpZip\Exception\RuntimeException;
use PhpZip\Exception\ZipUnsupportMethodException;
use PhpZip\Model\Extra\ExtraFieldsCollection;
use PhpZip\Model\Extra\Fields\AsiExtraField;
use PhpZip\Model\Extra\Fields\ExtendedTimestampExtraField;
use PhpZip\Model\Extra\Fields\NtfsExtraField;
use PhpZip\Model\Extra\Fields\OldUnixExtraField;
use PhpZip\Model\Extra\Fields\UnicodePathExtraField;
use PhpZip\Model\Extra\Fields\WinZipAesExtraField;
use PhpZip\Model\Extra\ZipExtraField;
use PhpZip\Util\DateTimeConverter;
use PhpZip\Util\StringUtil;

/**
 * ZIP file entry.
 *
 * @see     https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
 *
 * @author  Ne-Lexa [email protected]
 * @license MIT
 */
class ZipEntry
{
    /** @var int the unknown value for numeric properties */
    const UNKNOWN = -1;

    /**
     * @var int DOS platform
     *
     * @deprecated Use {@see ZipPlatform::OS_DOS}
     */
    const PLATFORM_FAT = ZipPlatform::OS_DOS;

    /**
     * @var int Unix platform
     *
     * @deprecated Use {@see ZipPlatform::OS_UNIX}
     */
    const PLATFORM_UNIX = ZipPlatform::OS_UNIX;

    /**
     * @var int MacOS platform
     *
     * @deprecated Use {@see ZipPlatform::OS_MAC_OSX}
     */
    const PLATFORM_OS_X = ZipPlatform::OS_MAC_OSX;

    /**
     * Pseudo compression method for WinZip AES encrypted entries.
     * Require php extension openssl or mcrypt.
     *
     * @deprecated Use {@see ZipCompressionMethod::WINZIP_AES}
     */
    const METHOD_WINZIP_AES = ZipCompressionMethod::WINZIP_AES;

    /** @var string Entry name (filename in archive) */
    private $name;

    /** @var bool Is directory */
    private $isDirectory;

    /** @var ZipData|null Zip entry contents */
    private $data;

    /** @var int Made by platform */
    private $createdOS = self::UNKNOWN;

    /** @var int Extracted by platform */
    private $extractedOS = self::UNKNOWN;

    /** @var int Software version */
    private $softwareVersion = self::UNKNOWN;

    /** @var int Version needed to extract */
    private $extractVersion = self::UNKNOWN;

    /** @var int Compression method */
    private $compressionMethod = self::UNKNOWN;

    /** @var int General purpose bit flags */
    private $generalPurposeBitFlags = 0;

    /** @var int Dos time */
    private $dosTime = self::UNKNOWN;

    /** @var int Crc32 */
    private $crc = self::UNKNOWN;

    /** @var int Compressed size */
    private $compressedSize = self::UNKNOWN;

    /** @var int Uncompressed size */
    private $uncompressedSize = self::UNKNOWN;

    /** @var int Internal attributes */
    private $internalAttributes = 0;

    /** @var int External attributes */
    private $externalAttributes = 0;

    /** @var int relative Offset Of Local File Header */
    private $localHeaderOffset = 0;

    /**
     * Collections of Extra Fields in Central Directory.
     * Keys from Header ID [int] and value Extra Field [ExtraField].
     *
     * @var ExtraFieldsCollection
     */
    protected $cdExtraFields;

    /**
     * Collections of Extra Fields int local header.
     * Keys from Header ID [int] and value Extra Field [ExtraField].
     *
     * @var ExtraFieldsCollection
     */
    protected $localExtraFields;

    /** @var string|null comment field */
    private $comment;

    /** @var string|null entry password for read or write encryption data */
    private $password;

    /** @var int encryption method */
    private $encryptionMethod = ZipEncryptionMethod::NONE;

    /** @var int */
    private $compressionLevel = ZipCompressionLevel::NORMAL;

    /** @var string|null */
    private $charset;

    /**
     * ZipEntry constructor.
     *
     * @param string      $name    Entry name
     * @param string|null $charset DOS charset
     */
    public function __construct($name, $charset = null)
    {
        $this->setName($name, $charset);

        $this->cdExtraFields = new ExtraFieldsCollection();
        $this->localExtraFields = new ExtraFieldsCollection();
    }

    /**
     * This method only internal use.
     *
     * @param string      $name
     * @param int         $createdOS
     * @param int         $extractedOS
     * @param int         $softwareVersion
     * @param int         $extractVersion
     * @param int         $compressionMethod
     * @param int         $gpbf
     * @param int         $dosTime
     * @param int         $crc
     * @param int         $compressedSize
     * @param int         $uncompressedSize
     * @param int         $internalAttributes
     * @param int         $externalAttributes
     * @param int         $offsetLocalHeader
     * @param string|null $comment
     * @param string|null $charset
     *
     * @return ZipEntry
     *
     * @internal
     *
     * @noinspection PhpTooManyParametersInspection
     */
    public static function create(
        $name,
        $createdOS,
        $extractedOS,
        $softwareVersion,
        $extractVersion,
        $compressionMethod,
        $gpbf,
        $dosTime,
        $crc,
        $compressedSize,
        $uncompressedSize,
        $internalAttributes,
        $externalAttributes,
        $offsetLocalHeader,
        $comment,
        $charset
    ) {
        $entry = new self($name);
        $entry->createdOS = (int) $createdOS;
        $entry->extractedOS = (int) $extractedOS;
        $entry->softwareVersion = (int) $softwareVersion;
        $entry->extractVersion = (int) $extractVersion;
        $entry->compressionMethod = (int) $compressionMethod;
        $entry->generalPurposeBitFlags = (int) $gpbf;
        $entry->dosTime = (int) $dosTime;
        $entry->crc = (int) $crc;
        $entry->compressedSize = (int) $compressedSize;
        $entry->uncompressedSize = (int) $uncompressedSize;
        $entry->internalAttributes = (int) $internalAttributes;
        $entry->externalAttributes = (int) $externalAttributes;
        $entry->localHeaderOffset = (int) $offsetLocalHeader;
        $entry->setComment($comment);
        $entry->setCharset($charset);
        $entry->updateCompressionLevel();

        return $entry;
    }

    /**
     * Set entry name.
     *
     * @param string      $name    New entry name
     * @param string|null $charset
     *
     * @return ZipEntry
     */
    private function setName($name, $charset = null)
    {
        if ($name === null) {

            throw new InvalidArgumentException('zip entry name is null');
        }

        $name = ltrim((string) $name, '\\/');

        if ($name === '') {
            throw new InvalidArgumentException('Empty zip entry name');
        }

        $name = (string) $name;
        $length = \strlen($name);

        if ($length > 0xffff) {
            throw new InvalidArgumentException('Illegal zip entry name parameter');
        }

        $this->setCharset($charset);

        if ($this->charset === null && !StringUtil::isASCII($name)) {
            $this->enableUtf8Name(true);
        }
        $this->name = $name;
        $this->isDirectory = ($length = \strlen($name)) >= 1 && $name[$length - 1] === '/';
        $this->externalAttributes = $this->isDirectory ? DosAttrs::DOS_DIRECTORY : DosAttrs::DOS_ARCHIVE;

        if ($this->extractVersion !== self::UNKNOWN) {
            $this->extractVersion = max(
                $this->extractVersion,
                $this->isDirectory ?
                    ZipVersion::v20_DEFLATED_FOLDER_ZIPCRYPTO :
                    ZipVersion::v10_DEFAULT_MIN
            );
        }

        return $this;
    }

    /**
     * @param string|null $charset
     *
     * @return ZipEntry
     *
     * @see DosCodePage::getCodePages()
     */
    public function setCharset($charset = null)
    {
        if ($charset !== null && $charset === '') {
            throw new InvalidArgumentException('Empty charset');
        }
        $this->charset = $charset;

        return $this;
    }

    /**
     * @return string|null
     */
    public function getCharset()
    {
        return $this->charset;
    }

    /**
     * @param string $newName New entry name
     *
     * @return ZipEntry new {@see ZipEntry} object with new name
     *
     * @internal
     */
    public function rename($newName)
    {
        $newEntry = clone $this;
        $newEntry->setName($newName);

        $newEntry->removeExtraField(UnicodePathExtraField::HEADER_ID);

        return $newEntry;
    }

    /**
     * Returns the ZIP entry name.
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @return ZipData|null
     *
     * @internal
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * @param ZipData|null $data
     *
     * @internal
     */
    public function setData($data)
    {
        $this->data = $data;
    }

    /**
     * @return int Get platform
     *
     * @deprecated Use {@see ZipEntry::getCreatedOS()}
     */
    public function getPlatform()
    {
        @trigger_error(__METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::getCreatedOS()', \E_USER_DEPRECATED);

        return $this->getCreatedOS();
    }

    /**
     * @param int $platform
     *
     * @return ZipEntry
     *
     * @deprecated Use {@see ZipEntry::setCreatedOS()}
     */
    public function setPlatform($platform)
    {
        @trigger_error(__METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::setCreatedOS()', \E_USER_DEPRECATED);

        return $this->setCreatedOS($platform);
    }

    /**
     * @return int platform
     */
    public function getCreatedOS()
    {
        return $this->createdOS;
    }

    /**
     * Set platform.
     *
     * @param int $platform
     *
     * @return ZipEntry
     */
    public function setCreatedOS($platform)
    {
        $platform = (int) $platform;

        if ($platform < 0x00 || $platform > 0xff) {
            throw new InvalidArgumentException('Platform out of range');
        }
        $this->createdOS = $platform;

        return $this;
    }

    /**
     * @return int
     */
    public function getExtractedOS()
    {
        return $this->extractedOS;
    }

    /**
     * Set extracted OS.
     *
     * @param int $platform
     *
     * @return ZipEntry
     */
    public function setExtractedOS($platform)
    {
        $platform = (int) $platform;

        if ($platform < 0x00 || $platform > 0xff) {
            throw new InvalidArgumentException('Platform out of range');
        }
        $this->extractedOS = $platform;

        return $this;
    }

    /**
     * @return int
     */
    public function getSoftwareVersion()
    {
        if ($this->softwareVersion === self::UNKNOWN) {
            return $this->getExtractVersion();
        }

        return $this->softwareVersion;
    }

    /**
     * @param int $softwareVersion
     *
     * @return ZipEntry
     */
    public function setSoftwareVersion($softwareVersion)
    {
        $this->softwareVersion = (int) $softwareVersion;

        return $this;
    }

    /**
     * Version needed to extract.
     *
     * @return int
     *
     * @deprecated Use {@see ZipEntry::getExtractVersion()}
     */
    public function getVersionNeededToExtract()
    {
        @trigger_error(__METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::getExtractVersion()', \E_USER_DEPRECATED);

        return $this->getExtractVersion();
    }

    /**
     * Version needed to extract.
     *
     * @return int
     */
    public function getExtractVersion()
    {
        if ($this->extractVersion === self::UNKNOWN) {
            if (ZipEncryptionMethod::isWinZipAesMethod($this->encryptionMethod)) {
                return ZipVersion::v51_ENCR_AES_RC2_CORRECT;
            }

            if ($this->compressionMethod === ZipCompressionMethod::BZIP2) {
                return ZipVersion::v46_BZIP2;
            }

            if ($this->isZip64ExtensionsRequired()) {
                return ZipVersion::v45_ZIP64_EXT;
            }

            if (
                $this->compressionMethod === ZipCompressionMethod::DEFLATED ||
                $this->isDirectory ||
                $this->encryptionMethod === ZipEncryptionMethod::PKWARE
            ) {
                return ZipVersion::v20_DEFLATED_FOLDER_ZIPCRYPTO;
            }

            return ZipVersion::v10_DEFAULT_MIN;
        }

        return $this->extractVersion;
    }

    /**
     * Set version needed to extract.
     *
     * @param int $version
     *
     * @return ZipEntry
     *
     * @deprecated Use {@see ZipEntry::setExtractVersion()}
     */
    public function setVersionNeededToExtract($version)
    {
        @trigger_error(__METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::setExtractVersion()', \E_USER_DEPRECATED);

        return $this->setExtractVersion($version);
    }

    /**
     * Set version needed to extract.
     *
     * @param int $version
     *
     * @return ZipEntry
     */
    public function setExtractVersion($version)
    {
        $this->extractVersion = max(ZipVersion::v10_DEFAULT_MIN, (int) $version);

        return $this;
    }

    /**
     * Returns the compressed size of this entry.
     *
     * @return int
     */
    public function getCompressedSize()
    {
        return $this->compressedSize;
    }

    /**
     * Sets the compressed size of this entry.
     *
     * @param int $compressedSize the Compressed Size
     *
     * @return ZipEntry
     *
     * @internal
     */
    public function setCompressedSize($compressedSize)
    {
        $compressedSize = (int) $compressedSize;

        if ($compressedSize < self::UNKNOWN) {
            throw new InvalidArgumentException('Compressed size < ' . self::UNKNOWN);
        }
        $this->compressedSize = $compressedSize;

        return $this;
    }

    /**
     * Returns the uncompressed size of this entry.
     *
     * @return int
     *
     * @deprecated Use {@see ZipEntry::getUncompressedSize()}
     */
    public function getSize()
    {
        @trigger_error(__METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::getUncompressedSize()', \E_USER_DEPRECATED);

        return $this->getUncompressedSize();
    }

    /**
     * Sets the uncompressed size of this entry.
     *
     * @param int $size the (Uncompressed) Size
     *
     * @return ZipEntry
     *
     * @deprecated Use {@see ZipEntry::setUncompressedSize()}
     *
     * @internal
     */
    public function setSize($size)
    {
        @trigger_error(__METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::setUncompressedSize()', \E_USER_DEPRECATED);

        return $this->setUncompressedSize($size);
    }

    /**
     * Returns the uncompressed size of this entry.
     *
     * @return int
     */
    public function getUncompressedSize()
    {
        return $this->uncompressedSize;
    }

    /**
     * Sets the uncompressed size of this entry.
     *
     * @param int $uncompressedSize the (Uncompressed) Size
     *
     * @return ZipEntry
     *
     * @internal
     */
    public function setUncompressedSize($uncompressedSize)
    {
        $uncompressedSize = (int) $uncompressedSize;

        if ($uncompressedSize < self::UNKNOWN) {
            throw new InvalidArgumentException('Uncompressed size < ' . self::UNKNOWN);
        }
        $this->uncompressedSize = $uncompressedSize;

        return $this;
    }

    /**
     * Return relative Offset Of Local File Header.
     *
     * @return int
     */
    public function getLocalHeaderOffset()
    {
        return $this->localHeaderOffset;
    }

    /**
     * @param int $localHeaderOffset
     *
     * @return ZipEntry
     *
     * @internal
     */
    public function setLocalHeaderOffset($localHeaderOffset)
    {
        $localHeaderOffset = (int) $localHeaderOffset;

        if ($localHeaderOffset < 0) {
            throw new InvalidArgumentException('Negative $localHeaderOffset');
        }
        $this->localHeaderOffset = $localHeaderOffset;

        return $this;
    }

    /**
     * Return relative Offset Of Local File Header.
     *
     * @return int
     *
     * @deprecated Use {@see ZipEntry::getLocalHeaderOffset()}
     */
    public function getOffset()
    {
        @trigger_error(
            __METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::getLocalHeaderOffset()',
            \E_USER_DEPRECATED
        );

        return $this->getLocalHeaderOffset();
    }

    /**
     * @param int $offset
     *
     * @return ZipEntry
     *
     * @deprecated Use {@see ZipEntry::setLocalHeaderOffset()}
     *
     * @internal
     */
    public function setOffset($offset)
    {
        @trigger_error(
            __METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::setLocalHeaderOffset()',
            \E_USER_DEPRECATED
        );

        return $this->setLocalHeaderOffset($offset);
    }

    /**
     * Returns the General Purpose Bit Flags.
     *
     * @return int
     */
    public function getGeneralPurposeBitFlags()
    {
        return $this->generalPurposeBitFlags;
    }

    /**
     * Sets the General Purpose Bit Flags.
     *
     * @param int $gpbf general purpose bit flags
     *
     * @return ZipEntry
     *
     * @internal
     */
    public function setGeneralPurposeBitFlags($gpbf)
    {
        $gpbf = (int) $gpbf;

        if ($gpbf < 0x0000 || $gpbf > 0xffff) {
            throw new InvalidArgumentException('general purpose bit flags out of range');
        }
        $this->generalPurposeBitFlags = $gpbf;
        $this->updateCompressionLevel();

        return $this;
    }

    private function updateCompressionLevel()
    {
        if ($this->compressionMethod === ZipCompressionMethod::DEFLATED) {
            $bit1 = $this->isSetGeneralBitFlag(GeneralPurposeBitFlag::COMPRESSION_FLAG1);
            $bit2 = $this->isSetGeneralBitFlag(GeneralPurposeBitFlag::COMPRESSION_FLAG2);

            if ($bit1 && !$bit2) {
                $this->compressionLevel = ZipCompressionLevel::MAXIMUM;
            } elseif (!$bit1 && $bit2) {
                $this->compressionLevel = ZipCompressionLevel::FAST;
            } elseif ($bit1 && $bit2) {
                $this->compressionLevel = ZipCompressionLevel::SUPER_FAST;
            } else {
                $this->compressionLevel = ZipCompressionLevel::NORMAL;
            }
        }
    }

    /**
     * @param int  $mask
     * @param bool $enable
     *
     * @return ZipEntry
     */
    private function setGeneralBitFlag($mask, $enable)
    {
        if ($enable) {
            $this->generalPurposeBitFlags |= $mask;
        } else {
            $this->generalPurposeBitFlags &= ~$mask;
        }

        return $this;
    }

    /**
     * @param int $mask
     *
     * @return bool
     */
    private function isSetGeneralBitFlag($mask)
    {
        return ($this->generalPurposeBitFlags & $mask) === $mask;
    }

    /**
     * @return bool
     */
    public function isDataDescriptorEnabled()
    {
        return $this->isSetGeneralBitFlag(GeneralPurposeBitFlag::DATA_DESCRIPTOR);
    }

    /**
     * Enabling or disabling the use of the Data Descriptor block.
     *
     * @param bool $enabled
     */
    public function enableDataDescriptor($enabled = true)
    {
        $this->setGeneralBitFlag(GeneralPurposeBitFlag::DATA_DESCRIPTOR, (bool) $enabled);
    }

    /**
     * @param bool $enabled
     */
    public function enableUtf8Name($enabled)
    {
        $this->setGeneralBitFlag(GeneralPurposeBitFlag::UTF8, (bool) $enabled);
    }

    /**
     * @return bool
     */
    public function isUtf8Flag()
    {
        return $this->isSetGeneralBitFlag(GeneralPurposeBitFlag::UTF8);
    }

    /**
     * Returns true if and only if this ZIP entry is encrypted.
     *
     * @return bool
     */
    public function isEncrypted()
    {
        return $this->isSetGeneralBitFlag(GeneralPurposeBitFlag::ENCRYPTION);
    }

    /**
     * @return bool
     */
    public function isStrongEncryption()
    {
        return $this->isSetGeneralBitFlag(GeneralPurposeBitFlag::STRONG_ENCRYPTION);
    }

    /**
     * Sets the encryption property to false and removes any other
     * encryption artifacts.
     *
     * @return ZipEntry
     */
    public function disableEncryption()
    {
        $this->setEncrypted(false);
        $this->removeExtraField(WinZipAesExtraField::HEADER_ID);
        $this->encryptionMethod = ZipEncryptionMethod::NONE;
        $this->password = null;
        $this->extractVersion = self::UNKNOWN;

        return $this;
    }

    /**
     * Sets the encryption flag for this ZIP entry.
     *
     * @param bool $encrypted
     *
     * @return ZipEntry
     */
    private function setEncrypted($encrypted)
    {
        $encrypted = (bool) $encrypted;
        $this->setGeneralBitFlag(GeneralPurposeBitFlag::ENCRYPTION, $encrypted);

        return $this;
    }

    /**
     * Returns the compression method for this entry.
     *
     * @return int
     *
     * @deprecated Use {@see ZipEntry::getCompressionMethod()}
     */
    public function getMethod()
    {
        @trigger_error(
            __METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::getCompressionMethod()',
            \E_USER_DEPRECATED
        );

        return $this->getCompressionMethod();
    }

    /**
     * Returns the compression method for this entry.
     *
     * @return int
     */
    public function getCompressionMethod()
    {
        return $this->compressionMethod;
    }

    /**
     * Sets the compression method for this entry.
     *
     * @param int $method
     *
     * @throws ZipUnsupportMethodException
     *
     * @return ZipEntry
     *
     * @deprecated Use {@see ZipEntry::setCompressionMethod()}
     */
    public function setMethod($method)
    {
        @trigger_error(
            __METHOD__ . ' is deprecated. Use ' . __CLASS__ . '::setCompressionMethod()',
            \E_USER_DEPRECATED
        );

        return $this->setCompressionMethod($method);
    }

    /**
     * Sets the compression method for this entry.
     *
     * @param int $compressionMethod
     *
     * @throws ZipUnsupportMethodException
     *
     * @return ZipEntry
     *
     * @see ZipCompressionMethod::STORED
     * @see ZipCompressionMethod::DEFLATED
     * @see ZipCompressionMethod::BZIP2
     */
    public function setCompressionMethod($compressionMethod)
    {
        $compressionMethod = (int) $compressionMethod;

        if ($compressionMethod < 0x0000 || $compressionMethod > 0xffff) {
            throw new InvalidArgumentException('method out of range: ' . $compressionMethod);
        }

        ZipCompressionMethod::checkSupport($compressionMethod);

        $this->compressionMethod = $compressionMethod;
        $this->updateCompressionLevel();
        $this->extractVersion = self::UNKNOWN;

        return $this;
    }

    /**
     * Get Unix Timestamp.
     *
     * @return int
     */
    public function getTime()
    {
        if ($this->getDosTime() === self::UNKNOWN) {
            return self::UNKNOWN;
        }

        return DateTimeConverter::msDosToUnix($this->getDosTime());
    }

    /**
     * Get Dos Time.
     *
     * @return int
     */
    public function getDosTime()
    {
        return $this->dosTime;
    }

    /**
     * Set Dos Time.
     *
     * @param int $dosTime
     *
     * @return ZipEntry
     */
    public function setDosTime($dosTime)
    {
        $dosTime = (int) $dosTime;

        if (\PHP_INT_SIZE === 8) {
            if ($dosTime < 0x00000000 || $dosTime > 0xffffffff) {
                throw new InvalidArgumentException('DosTime out of range');
            }
        }

        $this->dosTime = $dosTime;

        return $this;
    }

    /**
     * Set time from unix timestamp.
     *
     * @param int $unixTimestamp
     *
     * @return ZipEntry
     */
    public function setTime($unixTimestamp)
    {
        if ($unixTimestamp !== self::UNKNOWN) {
            $this->setDosTime(DateTimeConverter::unixToMsDos($unixTimestamp));
        } else {
            $this->dosTime = 0;
        }

        return $this;
    }

    /**
     * Returns the external file attributes.
     *
     * @return int the external file attributes
     */
    public function getExternalAttributes()
    {
        return $this->externalAttributes;
    }

    /**
     * Sets the external file attributes.
     *
     * @param int $externalAttributes the external file attributes
     *
     * @return ZipEntry
     */
    public function setExternalAttributes($externalAttributes)
    {
        $this->externalAttributes = (int) $externalAttributes;

        if (\PHP_INT_SIZE === 8) {
            if ($externalAttributes < 0x00000000 || $externalAttributes > 0xffffffff) {
                throw new InvalidArgumentException('external attributes out of range: ' . $externalAttributes);
            }
        }

        $this->externalAttributes = $externalAttributes;

        return $this;
    }

    /**
     * Returns the internal file attributes.
     *
     * @return int the internal file attributes
     */
    public function getInternalAttributes()
    {
        return $this->internalAttributes;
    }

    /**
     * Sets the internal file attributes.
     *
     * @param int $internalAttributes the internal file attributes
     *
     * @return ZipEntry
     */
    public function setInternalAttributes($internalAttributes)
    {
        $internalAttributes = (int) $internalAttributes;

        if ($internalAttributes < 0x0000 || $internalAttributes > 0xffff) {
            throw new InvalidArgumentException('internal attributes out of range');
        }
        $this->internalAttributes = $internalAttributes;

        return $this;
    }

    /**
     * Returns true if and only if this ZIP entry represents a directory entry
     * (i.e. end with '/').
     *
     * @return bool
     */
    final public function isDirectory()
    {
        return $this->isDirectory;
    }

    /**
     * @return ExtraFieldsCollection
     */
    public function getCdExtraFields()
    {
        return $this->cdExtraFields;
    }

    /**
     * @param int $headerId
     *
     * @return ZipExtraField|null
     */
    public function getCdExtraField($headerId)
    {
        return $this->cdExtraFields->get((int) $headerId);
    }

    /**
     * @param ExtraFieldsCollection $cdExtraFields
     *
     * @return ZipEntry
     */
    public function setCdExtraFields(ExtraFieldsCollection $cdExtraFields)
    {
        $this->cdExtraFields = $cdExtraFields;

        return $this;
    }

    /**
     * @return ExtraFieldsCollection
     */
    public function getLocalExtraFields()
    {
        return $this->localExtraFields;
    }

    /**
     * @param int $headerId
     *
     * @return ZipExtraField|null
     */
    public function getLocalExtraField($headerId)
    {
        return $this->localExtraFields[(int) $headerId];
    }

    /**
     * @param ExtraFieldsCollection $localExtraFields
     *
     * @return ZipEntry
     */
    public function setLocalExtraFields(ExtraFieldsCollection $localExtraFields)
    {
        $this->localExtraFields = $localExtraFields;

        return $this;
    }

    /**
     * @param int $headerId
     *
     * @return ZipExtraField|null
     */
    public function getExtraField($headerId)
    {
        $headerId = (int) $headerId;
        $local = $this->getLocalExtraField($headerId);

        if ($local === null) {
            return $this->getCdExtraField($headerId);
        }

        return $local;
    }

    /**
     * @param int $headerId
     *
     * @return bool
     */
    public function hasExtraField($headerId)
    {
        $headerId = (int) $headerId;

        return
            isset($this->localExtraFields[$headerId]) ||
            isset($this->cdExtraFields[$headerId]);
    }

    /**
     * @param int $headerId
     */
    public function removeExtraField($headerId)
    {
        $headerId = (int) $headerId;

        $this->cdExtraFields->remove($headerId);
        $this->localExtraFields->remove($headerId);
    }

    /**
     * @param ZipExtraField $zipExtraField
     */
    public function addExtraField(ZipExtraField $zipExtraField)
    {
        $this->addLocalExtraField($zipExtraField);
        $this->addCdExtraField($zipExtraField);
    }

    /**
     * @param ZipExtraField $zipExtraField
     */
    public function addLocalExtraField(ZipExtraField $zipExtraField)
    {
        $this->localExtraFields->add($zipExtraField);
    }

    /**
     * @param ZipExtraField $zipExtraField
     */
    public function addCdExtraField(ZipExtraField $zipExtraField)
    {
        $this->cdExtraFields->add($zipExtraField);
    }

    /**
     * Returns comment entry.
     *
     * @return string
     */
    public function getComment()
    {
        return $this->comment !== null ? $this->comment : '';
    }

    /**
     * Set entry comment.
     *
     * @param string|null $comment
     *
     * @return ZipEntry
     */
    public function setComment($comment)
    {
        if ($comment !== null) {
            $commentLength = \strlen($comment);

            if ($commentLength > 0xffff) {
                throw new InvalidArgumentException('Comment too long');
            }

            if ($this->charset === null && !StringUtil::isASCII($comment)) {
                $this->enableUtf8Name(true);
            }
        }
        $this->comment = $comment;

        return $this;
    }

    /**
     * @return bool
     */
    public function isDataDescriptorRequired()
    {
        return ($this->getCrc() | $this->getCompressedSize() | $this->getUncompressedSize()) === self::UNKNOWN;
    }

    /**
     * Return crc32 content or 0 for WinZip AES v2.
     *
     * @return int
     */
    public function getCrc()
    {
        return $this->crc;
    }

    /**
     * Set crc32 content.
     *
     * @param int $crc
     *
     * @return ZipEntry
     *
     * @internal
     */
    public function setCrc($crc)
    {
        $this->crc = (int) $crc;

        return $this;
    }

    /**
     * @return string|null
     */
    public function getPassword()
    {
        return $this->password;
    }

    /**
     * Set password and encryption method from entry.
     *
     * @param string|null $password
     * @param int|null    $encryptionMethod
     *
     * @return ZipEntry
     */
    public function setPassword($password, $encryptionMethod = null)
    {
        if (!$this->isDirectory) {
            if ($password === null || $password === '') {
                $this->password = null;
                $this->disableEncryption();
            } else {
                $this->password = (string) $password;

                if ($encryptionMethod === null && $this->encryptionMethod === ZipEncryptionMethod::NONE) {
                    $encryptionMethod = ZipEncryptionMethod::WINZIP_AES_256;
                }

                if ($encryptionMethod !== null) {
                    $this->setEncryptionMethod($encryptionMethod);
                }
                $this->setEncrypted(true);
            }
        }

        return $this;
    }

    /**
     * @return int
     */
    public function getEncryptionMethod()
    {
        return $this->encryptionMethod;
    }

    /**
     * Set encryption method.
     *
     * @param int|null $encryptionMethod
     *
     * @return ZipEntry
     *
     * @see ZipEncryptionMethod::NONE
     * @see ZipEncryptionMethod::PKWARE
     * @see ZipEncryptionMethod::WINZIP_AES_256
     * @see ZipEncryptionMethod::WINZIP_AES_192
     * @see ZipEncryptionMethod::WINZIP_AES_128
     */
    public function setEncryptionMethod($encryptionMethod)
    {
        if ($encryptionMethod === null) {
            $encryptionMethod = ZipEncryptionMethod::NONE;
        }

        $encryptionMethod = (int) $encryptionMethod;
        ZipEncryptionMethod::checkSupport($encryptionMethod);
        $this->encryptionMethod = $encryptionMethod;

        $this->setEncrypted($this->encryptionMethod !== ZipEncryptionMethod::NONE);
        $this->extractVersion = self::UNKNOWN;

        return $this;
    }

    /**
     * @return int
     */
    public function getCompressionLevel()
    {
        return $this->compressionLevel;
    }

    /**
     * @param int $compressionLevel
     *
     * @return ZipEntry
     */
    public function setCompressionLevel($compressionLevel)
    {
        $compressionLevel = (int) $compressionLevel;

        if ($compressionLevel === self::UNKNOWN) {
            $compressionLevel = ZipCompressionLevel::NORMAL;
        }

        if (
            $compressionLevel < ZipCompressionLevel::LEVEL_MIN ||
            $compressionLevel > ZipCompressionLevel::LEVEL_MAX
        ) {
            throw new InvalidArgumentException(
                'Invalid compression level. Minimum level ' .
                ZipCompressionLevel::LEVEL_MIN . '. Maximum level ' . ZipCompressionLevel::LEVEL_MAX
            );
        }
        $this->compressionLevel = $compressionLevel;

        $this->updateGbpfCompLevel();

        return $this;
    }

    /**
     * Update general purpose bit flogs.
     */
    private function updateGbpfCompLevel()
    {
        if ($this->compressionMethod === ZipCompressionMethod::DEFLATED) {
            $bit1 = false;
            $bit2 = false;

            switch ($this->compressionLevel) {
                case ZipCompressionLevel::MAXIMUM:
                    $bit1 = true;
                    break;

                case ZipCompressionLevel::FAST:
                    $bit2 = true;
                    break;

                case ZipCompressionLevel::SUPER_FAST:
                    $bit1 = true;
                    $bit2 = true;
                    break;
                // default is ZipCompressionLevel::NORMAL
            }

            $this->generalPurposeBitFlags |= ($bit1 ? GeneralPurposeBitFlag::COMPRESSION_FLAG1 : 0);
            $this->generalPurposeBitFlags |= ($bit2 ? GeneralPurposeBitFlag::COMPRESSION_FLAG2 : 0);
        }
    }

    /**
     * Sets Unix permissions in a way that is understood by Info-Zip's
     * unzip command.
     *
     * @param int $mode mode an int value
     *
     * @return ZipEntry
     */
    public function setUnixMode($mode)
    {
        $mode = (int) $mode;
        $this->setExternalAttributes(
            ($mode << 16)
            // MS-DOS read-only attribute
            | (($mode & UnixStat::UNX_IWUSR) === 0 ? DosAttrs::DOS_HIDDEN : 0)
            // MS-DOS directory flag
            | ($this->isDirectory() ? DosAttrs::DOS_DIRECTORY : DosAttrs::DOS_ARCHIVE)
        );
        $this->createdOS = ZipPlatform::OS_UNIX;

        return $this;
    }

    /**
     * Unix permission.
     *
     * @return int the unix permissions
     */
    public function getUnixMode()
    {
        $mode = 0;

        if ($this->createdOS === ZipPlatform::OS_UNIX) {
            $mode = ($this->externalAttributes >> 16) & 0xFFFF;
        } elseif ($this->hasExtraField(AsiExtraField::HEADER_ID)) {
            /** @var AsiExtraField $asiExtraField */
            $asiExtraField = $this->getExtraField(AsiExtraField::HEADER_ID);
            $mode = $asiExtraField->getMode();
        }

        if ($mode > 0) {
            return $mode;
        }

        return $this->isDirectory ? 040755 : 0100644;
    }

    /**
     * Offset MUST be considered in decision about ZIP64 format - see
     * description of Data Descriptor in ZIP File Format Specification.
     *
     * @return bool
     */
    public function isZip64ExtensionsRequired()
    {
        return $this->compressedSize > ZipConstants::ZIP64_MAGIC
            || $this->uncompressedSize > ZipConstants::ZIP64_MAGIC;
    }

    /**
     * Returns true if this entry represents a unix symlink,
     * in which case the entry's content contains the target path
     * for the symlink.
     *
     * @return bool true if the entry represents a unix symlink,
     *              false otherwise
     */
    public function isUnixSymlink()
    {
        return ($this->getUnixMode() & UnixStat::UNX_IFMT) === UnixStat::UNX_IFLNK;
    }

    /**
     * @return \DateTimeInterface
     */
    public function getMTime()
    {
        /** @var NtfsExtraField|null $ntfsExtra */
        $ntfsExtra = $this->getExtraField(NtfsExtraField::HEADER_ID);

        if ($ntfsExtra !== null) {
            return $ntfsExtra->getModifyDateTime();
        }

        /** @var ExtendedTimestampExtraField|null $extendedExtra */
        $extendedExtra = $this->getExtraField(ExtendedTimestampExtraField::HEADER_ID);

        if ($extendedExtra !== null && ($mtime = $extendedExtra->getModifyDateTime()) !== null) {
            return $mtime;
        }

        /** @var OldUnixExtraField|null $oldUnixExtra */
        $oldUnixExtra = $this->getExtraField(OldUnixExtraField::HEADER_ID);

        if ($oldUnixExtra !== null && ($mtime = $oldUnixExtra->getModifyDateTime()) !== null) {
            return $mtime;
        }

        $timestamp = $this->getTime();

        try {
            return new \DateTimeImmutable('@' . $timestamp);
        } catch (\Exception $e) {
            throw new RuntimeException('Error create DateTime object with timestamp ' . $timestamp, 1, $e);
        }
    }

    /**
     * @return \DateTimeInterface|null
     */
    public function getATime()
    {
        /** @var NtfsExtraField|null $ntfsExtra */
        $ntfsExtra = $this->getExtraField(NtfsExtraField::HEADER_ID);

        if ($ntfsExtra !== null) {
            return $ntfsExtra->getAccessDateTime();
        }

        /** @var ExtendedTimestampExtraField|null $extendedExtra */
        $extendedExtra = $this->getExtraField(ExtendedTimestampExtraField::HEADER_ID);

        if ($extendedExtra !== null && ($atime = $extendedExtra->getAccessDateTime()) !== null) {
            return $atime;
        }

        /** @var OldUnixExtraField|null $oldUnixExtra */
        $oldUnixExtra = $this->getExtraField(OldUnixExtraField::HEADER_ID);

        if ($oldUnixExtra !== null) {
            return $oldUnixExtra->getAccessDateTime();
        }

        return null;
    }

    /**
     * @return \DateTimeInterface|null
     */
    public function getCTime()
    {
        /** @var NtfsExtraField|null $ntfsExtra */
        $ntfsExtra = $this->getExtraField(NtfsExtraField::HEADER_ID);

        if ($ntfsExtra !== null) {
            return $ntfsExtra->getCreateDateTime();
        }

        /** @var ExtendedTimestampExtraField|null $extendedExtra */
        $extendedExtra = $this->getExtraField(ExtendedTimestampExtraField::HEADER_ID);

        if ($extendedExtra !== null) {
            return $extendedExtra->getCreateDateTime();
        }

        return null;
    }

    public function __clone()
    {
        $this->cdExtraFields = clone $this->cdExtraFields;
        $this->localExtraFields = clone $this->localExtraFields;

        if ($this->data !== null) {
            $this->data = clone $this->data;
        }
    }
}

Ne-Lexa / php-zip

Push — master ( d305ab...074443 )

ZipEntry::create() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like
