Rar::addFileFromString() - Code Metrics - Inspection of "Merge branch 'master' into 1.1.x" - wapmorgan/UnifiedArchive - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 1.1.x ( 3d3019...6d4a67 )

by f

created 2021-03-01 01:03 UTC

Rar::addFileFromString() A

↳ Parent: Rar

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	1
c	0
b	0
f	0
dl	0
loc	3
ccs	0
cts	2
cp	0
rs	10
cc	1
nc	1
nop	2
crap	2

<?php
namespace wapmorgan\UnifiedArchive\Drivers;

use Exception;
use wapmorgan\UnifiedArchive\ArchiveEntry;
use wapmorgan\UnifiedArchive\ArchiveInformation;
use wapmorgan\UnifiedArchive\Drivers\BasicDriver;
use wapmorgan\UnifiedArchive\Exceptions\ArchiveModificationException;
use wapmorgan\UnifiedArchive\Exceptions\UnsupportedOperationException;
use wapmorgan\UnifiedArchive\Formats;

class Rar extends BasicDriver
{
    const NONE_RAR_COMPRESSION = 48;

    /** @var \RarArchive */
    protected $rar;

    /**
     * @return array
     */
    public static function getSupportedFormats()
    {
        return [
            Formats::RAR,
        ];
    }

    /**
     * @param $format
     * @return bool
     */
    public static function checkFormatSupport($format)
    {
        switch ($format) {
            case Formats::RAR:
                return extension_loaded('rar');
        }
    }

    /**
     * @inheritDoc
     */
    public static function getDescription()
    {
        return 'adapter for ext-rar';
    }

    /**
     * @inheritDoc
     */
    public static function getInstallationInstruction()
    {
        return !extension_loaded('rar')
            ? 'install `rar` extension'
            : null;
    }

    /**
     * @inheritDoc
     */
    public static function canStream($format)
    {
        return true;
    }

    /**
     * @inheritDoc
     */
    public function __construct($archiveFileName, $format, $password = null)
    {
        \RarException::setUsingExceptions(true);
        $this->open($archiveFileName, $password);
    }

    /**
     * @param $archiveFileName
     * @param $password
     * @throws Exception
     */
    protected function open($archiveFileName, $password)
    {
        $this->rar = \RarArchive::open($archiveFileName, $password);
        if ($this->rar === false) {
            throw new Exception('Could not open Rar archive');
        }
    }

    /**
     * Rar format destructor
     */
    public function __destruct()
    {
        $this->rar->close();
    }

    /**
     * @return ArchiveInformation
     */
    public function getArchiveInformation()
    {
        $information = new ArchiveInformation();
        foreach ($this->rar->getEntries() as $i => $entry) {
            if ($entry->isDirectory()) continue;
            $information->files[] = $entry->getName();
            $information->compressedFilesSize += $entry->getPackedSize();
            $information->uncompressedFilesSize += $entry->getUnpackedSize();
        }
        return $information;
    }

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

    /**
     * @return array
     */
    public function getFileNames()
    {
        $files = [];
        foreach ($this->rar->getEntries() as $i => $entry) {
            if ($entry->isDirectory()) continue;
            $files[] = $entry->getName();
        }
        return $files;
    }

    /**
     * @param string $fileName
     *
     * @return bool
     */
    public function isFileExists($fileName)
    {
        return $this->rar->getEntry($fileName) !== false;
    }

    /**
     * @param string $fileName
     *
     * @return ArchiveEntry|false
     */
    public function getFileData($fileName)
    {
        $entry = $this->rar->getEntry($fileName);
        return new ArchiveEntry($fileName, $entry->getPackedSize(), $entry->getUnpackedSize(),
            strtotime($entry->getFileTime()), $entry->getMethod() != self::NONE_RAR_COMPRESSION);
    }

    /**
     * @param string $fileName
     *
     * @return string|false
     */
    public function getFileContent($fileName)
    {
        $entry = $this->rar->getEntry($fileName);
        if ($entry->isDirectory()) return false;
        return stream_get_contents($entry->getStream());
    }

    /**
     * @param string $fileName
     *
     * @return bool|resource|string
     */
    public function getFileStream($fileName)
    {
        $entry = $this->rar->getEntry($fileName);
        if ($entry->isDirectory()) return false;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        return $entry->getStream();
    }

    /**
     * @param string $outputFolder
     * @param array  $files
     *
     * @return false|int
     */
    public function extractFiles($outputFolder, array $files)
    {
        $count = 0;
        foreach ($files as $file) {
            if ($this->rar->getEntry($file)->extract($outputFolder)) {
                $count++;
            }
        }
        return $count;
    }

    /**
     * @param string $outputFolder
     *
     * @return false|resource
     */
    public function extractArchive($outputFolder)
    {
        return $this->extractFiles($outputFolder, $this->getFileNames());

    }

    /**
     * @param string $inArchiveName
     * @param string $content
     * @return bool|void
     * @throws UnsupportedOperationException
     */
    public function addFileFromString($inArchiveName, $content)
    {
        throw new UnsupportedOperationException();
    }
}

1		<?php
2		namespace wapmorgan\UnifiedArchive\Drivers;
3
4		use Exception;
5		use wapmorgan\UnifiedArchive\ArchiveEntry;
6		use wapmorgan\UnifiedArchive\ArchiveInformation;
7		use wapmorgan\UnifiedArchive\Drivers\BasicDriver;
8		use wapmorgan\UnifiedArchive\Exceptions\ArchiveModificationException;
9		use wapmorgan\UnifiedArchive\Exceptions\UnsupportedOperationException;
10		use wapmorgan\UnifiedArchive\Formats;
11
12		class Rar extends BasicDriver
13		{
14		const NONE_RAR_COMPRESSION = 48;
15
16		/** @var \RarArchive */
17		protected $rar;
18
19		/**
20		* @return array
21		*/
22	1	public static function getSupportedFormats()
23		{
24		return [
25	1	Formats::RAR,
26		];
27		}
28
29		/**
30		* @param $format
31		* @return bool
32		*/
33		public static function checkFormatSupport($format)
34		{
35		switch ($format) {
36		case Formats::RAR:
37		return extension_loaded('rar');
38		}
39		}
40
41		/**
42		* @inheritDoc
43		*/
44		public static function getDescription()
45		{
46		return 'adapter for ext-rar';
47		}
48
49		/**
50		* @inheritDoc
51		*/
52		public static function getInstallationInstruction()
53		{
54		return !extension_loaded('rar')
55		? 'install `rar` extension'
56		: null;
57		}
58
59		/**
60		* @inheritDoc
61		*/
62		public static function canStream($format)
63		{
64		return true;
65		}
66
67		/**
68		* @inheritDoc
69		*/
70		public function __construct($archiveFileName, $format, $password = null)
71		{
72		\RarException::setUsingExceptions(true);
73		$this->open($archiveFileName, $password);
74		}
75
76		/**
77		* @param $archiveFileName
78		* @param $password
79		* @throws Exception
80		*/
81		protected function open($archiveFileName, $password)
82		{
83		$this->rar = \RarArchive::open($archiveFileName, $password);
84		if ($this->rar === false) {
85		throw new Exception('Could not open Rar archive');
86		}
87		}
88
89		/**
90		* Rar format destructor
91		*/
92		public function __destruct()
93		{
94		$this->rar->close();
95		}
96
97		/**
98		* @return ArchiveInformation
99		*/
100		public function getArchiveInformation()
101		{
102		$information = new ArchiveInformation();
103		foreach ($this->rar->getEntries() as $i => $entry) {
104		if ($entry->isDirectory()) continue;
105		$information->files[] = $entry->getName();
106		$information->compressedFilesSize += $entry->getPackedSize();
107		$information->uncompressedFilesSize += $entry->getUnpackedSize();
108		}
109		return $information;
110		}
111
112		/**
113		* @return string\|null
114		*/
115		public function getComment()
116		{
117		return $this->rar->getComment();
118		}
119
120		/**
121		* @return array
122		*/
123		public function getFileNames()
124		{
125		$files = [];
126		foreach ($this->rar->getEntries() as $i => $entry) {
127		if ($entry->isDirectory()) continue;
128		$files[] = $entry->getName();
129		}
130		return $files;
131		}
132
133		/**
134		* @param string $fileName
135		*
136		* @return bool
137		*/
138		public function isFileExists($fileName)
139		{
140		return $this->rar->getEntry($fileName) !== false;
141		}
142
143		/**
144		* @param string $fileName
145		*
146		* @return ArchiveEntry\|false
147		*/
148		public function getFileData($fileName)
149		{
150		$entry = $this->rar->getEntry($fileName);
151		return new ArchiveEntry($fileName, $entry->getPackedSize(), $entry->getUnpackedSize(),
152		strtotime($entry->getFileTime()), $entry->getMethod() != self::NONE_RAR_COMPRESSION);
153		}
154
155		/**
156		* @param string $fileName
157		*
158		* @return string\|false
159		*/
160		public function getFileContent($fileName)
161		{
162		$entry = $this->rar->getEntry($fileName);
163		if ($entry->isDirectory()) return false;
164		return stream_get_contents($entry->getStream());
165		}
166
167		/**
168		* @param string $fileName
169		*
170		* @return bool\|resource\|string
171		*/
172		public function getFileStream($fileName)
173		{
174		$entry = $this->rar->getEntry($fileName);
175		if ($entry->isDirectory()) return false;
		0 ignored issues – show Bug Best Practice introduced 2021-02-24 01:30 UTC by Report Bug Copy Issue Report The expression `return false` returns the type `false` which is incompatible with the return type mandated by `wapmorgan\UnifiedArchive...Driver::getFileStream()` of `resource`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
176		return $entry->getStream();
177		}
178
179		/**
180		* @param string $outputFolder
181		* @param array $files
182		*
183		* @return false\|int
184		*/
185		public function extractFiles($outputFolder, array $files)
186		{
187		$count = 0;
188		foreach ($files as $file) {
189		if ($this->rar->getEntry($file)->extract($outputFolder)) {
190		$count++;
191		}
192		}
193		return $count;
194		}
195
196		/**
197		* @param string $outputFolder
198		*
199		* @return false\|resource
200		*/
201		public function extractArchive($outputFolder)
202		{
203		return $this->extractFiles($outputFolder, $this->getFileNames());
		0 ignored issues – show Bug Best Practice introduced 2018-11-25 08:49 UTC by Report Bug Copy Issue Report The expression `return $this->extractFil... $this->getFileNames())` returns the type `integer` which is incompatible with the documented return type `false\|resource`. Loading history...
204		}
205
206		/**
207		* @param string $inArchiveName
208		* @param string $content
209		* @return bool\|void
210		* @throws UnsupportedOperationException
211		*/
212		public function addFileFromString($inArchiveName, $content)
213		{
214		throw new UnsupportedOperationException();
215		}
216		}

wapmorgan / UnifiedArchive

Push — 1.1.x ( 3d3019...6d4a67 )

Rar::addFileFromString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like