Tar::archiveTo() - Code Metrics - Inspection of "Add tar --exclude option - issue #83" - sebastianfeldmann/phpbu - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1d27bd...52e010 )

by Sebastian

created 2017-02-21 19:33 UTC

Tar::archiveTo() A

↳ Parent: Tar

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php
namespace phpbu\App\Cli\Executable;

use phpbu\App\Cli\Executable;
use phpbu\App\Exception;
use SebastianFeldmann\Cli\CommandLine;
use SebastianFeldmann\Cli\Command\Executable as Cmd;

/**
 * Tar Executable class.
 *
 * @package    phpbu
 * @subpackage Backup
 * @author     Sebastian Feldmann <[email protected]>
 * @copyright  Sebastian Feldmann <[email protected]>
 * @license    https://opensource.org/licenses/MIT The MIT License (MIT)
 * @link       http://phpbu.de/
 * @since      Class available since Release 1.0.0
 */
class Tar extends Abstraction implements Executable
{
    /**
     * Path to compress
     *
     * @var string
     */
    private $path;

    /**
     * Compression to use
     *
     * @var string
     */
    private $compression;

    /**
     * Path to dump file
     *
     * @var string
     */
    private $tarPathname;

    /**
     * List of excluded path.
     * --exclude='foo'
     *
     * @var array
     */
    private $excludes = [];

    /**
     * Ignore failed reads
     * --ignore-failed-read
     *
     * @var bool
     */
    private $ignoreFailedRead;

    /**
     * Should the source directory be removed.
     *
     * @var boolean
     */
    private $removeSourceDir = false;

    /**
     * List of available compressors
     *
     * @var array
     */
    private static $availableCompressions = [
        'bzip2' => 'j',
        'gzip'  => 'z',
    ];

    /**
     * Constructor.
     *
     * @param string $path
     */
    public function __construct(string $path = '')
    {
        $this->setup('tar', $path);
    }

    /**
     * Return 'tar' compressor option e.g. 'j' for bzip2.
     *
     * @param  string $compressor
     * @return string
     */
    protected function getCompressionOption(string $compressor) : string
    {
        return $this->isCompressionValid($compressor) ? self::$availableCompressions[$compressor] : '';
    }

    /**
     * Compress tar.
     *
     * @param  string $compression
     * @return \phpbu\App\Cli\Executable\Tar
     */
    public function useCompression(string $compression) : Tar
    {
        if ($this->isCompressionValid($compression)) {
            $this->compression = $this->getCompressionOption($compression);
        }
        return $this;
    }

    /**
     * Add an path to exclude.
     *
     * @param  string $path
     * @return \phpbu\App\Cli\Executable\Tar
     */
    public function addExclude(string $path) : Tar
    {
        $this->excludes[] = $path;
        return $this;
    }

    /**
     * Ignore failed reads setter.
     *
     * @param  bool $bool
     * @return \phpbu\App\Cli\Executable\Tar
     */
    public function ignoreFailedRead(bool $bool) : Tar
    {
        $this->ignoreFailedRead = $bool;
        return $this;
    }

    /**
     * Does the tar handle the compression.
     *
     * @return bool
     */
    public function handlesCompression() : bool
    {
        return !empty($this->compression);
    }

    /**
     * Set folder to compress.
     *
     * @param  string $path
     * @return \phpbu\App\Cli\Executable\Tar
     * @throws \phpbu\App\Exception
     */
    public function archiveDirectory(string $path) : Tar
    {
        $this->validateDirectory($path);
        $this->path = $path;
        return $this;
    }

    /**
     * Set target filename.
     *
     * @param  string $path
     * @return \phpbu\App\Cli\Executable\Tar
     */
    public function archiveTo(string $path) : Tar
    {
        $this->tarPathname = $path;
        return $this;
    }

    /**
     * Delete the source directory.
     *
     * @param  boolean $bool
     * @return \phpbu\App\Cli\Executable\Tar
     */
    public function removeSourceDirectory(bool $bool) : Tar
    {
        $this->removeSourceDir = $bool;
        return $this;
    }

    /**
     * Tar CommandLine generator.
     *
     * @return \SebastianFeldmann\Cli\CommandLine
     */
    protected function createCommandLine() : CommandLine
    {
        $this->validateSetup();

        $process = new CommandLine();
        $tar     = new Cmd($this->binary);

        foreach ($this->excludes as $path) {
            $tar->addOption('--exclude', $path);
        }

        $tar->addOptionIfNotEmpty('--ignore-failed-read', $this->ignoreFailedRead, false);
        $tar->addOption('-' . $this->compression . 'cf');
        $tar->addArgument($this->tarPathname);
        $tar->addOption('-C', dirname($this->path), ' ');
        $tar->addArgument(basename($this->path));

        $process->addCommand($tar);

        // delete the source data if requested
        if ($this->removeSourceDir) {
            $process->addCommand($this->getRmCommand());
        }

        return $process;
    }

    /**
     * Return 'rm' command.
     *
     * @return \SebastianFeldmann\Cli\Command\Executable
     */
    protected function getRmCommand() : Cmd
    {
        $rm = new Cmd('rm');
        $rm->addOption('-rf', $this->path, ' ');
        return $rm;
    }

    /**
     * Check directory to compress.
     *
     * @param  string $path
     * @throws \phpbu\App\Exception
     */
    private function validateDirectory(string $path)
    {
        if ($path === '.') {
            throw new Exception('unable to tar current working directory');
        }
    }

    /**
     * Check if source and target values are set.
     *
     * @throws \phpbu\App\Exception
     */
    private function validateSetup()
    {
        if (empty($this->path)) {
            throw new Exception('no directory to compress');
        }
        if (empty($this->tarPathname)) {
            throw new Exception('no target filename set');
        }
    }

    /**
     * Return true if a given compression is valid false otherwise.
     *
     * @param  string $compression
     * @return bool
     */
    public static function isCompressionValid(string  $compression) : bool
    {
        return isset(self::$availableCompressions[$compression]);
    }
}


1		<?php
2		namespace phpbu\App\Cli\Executable;
3
4		use phpbu\App\Cli\Executable;
5		use phpbu\App\Exception;
6		use SebastianFeldmann\Cli\CommandLine;
7		use SebastianFeldmann\Cli\Command\Executable as Cmd;
8
9		/**
10		* Tar Executable class.
11		*
12		* @package phpbu
13		* @subpackage Backup
14		* @author Sebastian Feldmann <[email protected]>
15		* @copyright Sebastian Feldmann <[email protected]>
16		* @license https://opensource.org/licenses/MIT The MIT License (MIT)
17		* @link http://phpbu.de/
18		* @since Class available since Release 1.0.0
19		*/
20		class Tar extends Abstraction implements Executable
21		{
22		/**
23		* Path to compress
24		*
25		* @var string
26		*/
27		private $path;
28
29		/**
30		* Compression to use
31		*
32		* @var string
33		*/
34		private $compression;
35
36		/**
37		* Path to dump file
38		*
39		* @var string
40		*/
41		private $tarPathname;
42
43		/**
44		* List of excluded path.
45		* --exclude='foo'
46		*
47		* @var array
48		*/
49		private $excludes = [];
50
51		/**
52		* Ignore failed reads
53		* --ignore-failed-read
54		*
55		* @var bool
56		*/
57		private $ignoreFailedRead;
58
59		/**
60		* Should the source directory be removed.
61		*
62		* @var boolean
63		*/
64		private $removeSourceDir = false;
65	13
66		/**
67	13	* List of available compressors
68	13	*
69	13	* @var array
70		*/
71		private static $availableCompressions = [
72		'bzip2' => 'j',
73		'gzip' => 'z',
74		];
75
76		/**
77	6	* Constructor.
78		*
79	6	* @param string $path
80		*/
81		public function __construct(string $path = '')
82		{
83		$this->setup('tar', $path);
84		}
85
86		/**
87		* Return 'tar' compressor option e.g. 'j' for bzip2.
88	8	*
89		* @param string $compressor
90	8	* @return string
91	6	*/
92	6	protected function getCompressionOption(string $compressor) : string
93	8	{
94		return $this->isCompressionValid($compressor) ? self::$availableCompressions[$compressor] : '';
95		}
96
97		/**
98		* Compress tar.
99		*
100		* @param string $compression
101	1	* @return \phpbu\App\Cli\Executable\Tar
102		*/
103	1	public function useCompression(string $compression) : Tar
104		{
105		if ($this->isCompressionValid($compression)) {
106		$this->compression = $this->getCompressionOption($compression);
107		}
108		return $this;
109		}
110
111		/**
112		* Add an path to exclude.
113	11	*
114		* @param string $path
115	11	* @return \phpbu\App\Cli\Executable\Tar
116	1	*/
117		public function addExclude(string $path) : Tar
118	10	{
119	10	$this->excludes[] = $path;
120		return $this;
121		}
122
123		/**
124		* Ignore failed reads setter.
125		*
126		* @param bool $bool
127		* @return \phpbu\App\Cli\Executable\Tar
128	9	*/
129		public function ignoreFailedRead(bool $bool) : Tar
130	9	{
131	9	$this->ignoreFailedRead = $bool;
132		return $this;
133		}
134
135		/**
136		* Does the tar handle the compression.
137		*
138		* @return bool
139		*/
140	2	public function handlesCompression() : bool
141		{
142	2	return !empty($this->compression);
143	2	}
144
145		/**
146		* Set folder to compress.
147		*
148		* @param string $path
149	11	* @return \phpbu\App\Cli\Executable\Tar
150		* @throws \phpbu\App\Exception
151		*/
152	11	public function archiveDirectory(string $path) : Tar
153	1	{
154		$this->validateDirectory($path);
155	10	$this->path = $path;
156	1	return $this;
157		}
158
159	9	/**
160	9	* Set target filename.
161		*
162		* @param string $path
163	9	* @return \phpbu\App\Cli\Executable\Tar
164	8	*/
165		public function archiveTo(string $path) : Tar
166	8	{
167		$this->tarPathname = $path;
168	9	return $this;
169	9	}
170	9
171	9	/**
172		* Delete the source directory.
173	9	*
174		* @param boolean $bool
175		* @return \phpbu\App\Cli\Executable\Tar
176	9	*/
177	2	public function removeSourceDirectory(bool $bool) : Tar
178	2	{
179		$this->removeSourceDir = $bool;
180	9	return $this;
181		}
182
183		/**
184		* Tar CommandLine generator.
185		*
186		* @return \SebastianFeldmann\Cli\CommandLine
187		*/
188	2	protected function createCommandLine() : CommandLine
189		{
190	2	$this->validateSetup();
191	2
192	2	$process = new CommandLine();
193	2	$tar = new Cmd($this->binary);
194	2
195	2	foreach ($this->excludes as $path) {
196		$tar->addOption('--exclude', $path);
197		}
198
199		$tar->addOptionIfNotEmpty('--ignore-failed-read', $this->ignoreFailedRead, false);
200		$tar->addOption('-' . $this->compression . 'cf');
201		$tar->addArgument($this->tarPathname);
202		$tar->addOption('-C', dirname($this->path), ' ');
203		$tar->addArgument(basename($this->path));
204	9
205		$process->addCommand($tar);
206	9
207		// delete the source data if requested
208		if ($this->removeSourceDir) {
209		$process->addCommand($this->getRmCommand());
210		}
211
212		return $process;
213		}
214
215		/**
216		* Return 'rm' command.
217		*
218		* @return \SebastianFeldmann\Cli\Command\Executable
219		*/
220		protected function getRmCommand() : Cmd
221		{
222		$rm = new Cmd('rm');
223		$rm->addOption('-rf', $this->path, ' ');
224		return $rm;
225		}
226
227		/**
228		* Check directory to compress.
229		*
230		* @param string $path
231		* @throws \phpbu\App\Exception
232		*/
233		private function validateDirectory(string $path)
234		{
235		if ($path === '.') {
236		throw new Exception('unable to tar current working directory');
237		}
238		}
239
240		/**
241		* Check if source and target values are set.
242		*
243		* @throws \phpbu\App\Exception
244		*/
245		private function validateSetup()
246		{
247		if (empty($this->path)) {
248		throw new Exception('no directory to compress');
249		}
250		if (empty($this->tarPathname)) {
251		throw new Exception('no target filename set');
252		}
253		}
254
255		/**
256		* Return true if a given compression is valid false otherwise.
257		*
258		* @param string $compression
259		* @return bool
260		*/
261		public static function isCompressionValid(string $compression) : bool
262		{
263		return isset(self::$availableCompressions[$compression]);
264		}
265		}
266

sebastianfeldmann / phpbu

Push — master ( 1d27bd...52e010 )

Tar::archiveTo() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like