phpbu\App\Backup\Collector

Complexity

Total Complexity

15

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	1	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getBackupFiles()	0	9	2
D	collect()	0	33	9
A	isValidDirectory()	0	4	2
A	isMatchingDirectory()	0	6	1

<?php
namespace phpbu\App\Backup;

use DirectoryIterator;
use SplFileInfo;
use phpbu\App\Util\Arr;
use phpbu\App\Util\Str;

/**
 * Collector
 *
 * @package    phpbu
 * @subpackage Backup
 * @author     Sebastian Feldmann <sebastian@phpbu.de>
 * @copyright  Sebastian Feldmann <sebastian@phpbu.de>
 * @license    https://opensource.org/licenses/MIT The MIT License (MIT)
 * @link       http://phpbu.de/
 * @since      Class available since Release 1.0.0
 */
class Collector
{
    /**
     * Backup target
     *
     * @var \phpbu\App\Backup\Target
     */
    protected $target;
    /**
     * Collection cache
     *
     * @var array<\phpbu\App\Backup\File>
     */
    protected $files;

    /**
     * Constructor
     *
     * @param Target $target
     */
    public function __construct(Target $target)
    {
        $this->target = $target;
    }

    /**
     * Get all created backups.
     *
     * @return \phpbu\App\Backup\File[]
     */
    public function getBackupFiles()
    {
        if (null === $this->files) {
            $this->files = [];
            // collect all matching backup files
            $this->collect($this->target->getPathThatIsNotChanging(), 0);
        }
        return $this->files;
    }

    /**
     * Recursive backup collecting.
     *
     * @param string  $path
     * @param integer $depth
     */
    protected function collect($path, $depth)
    {
        $dirIterator = new DirectoryIterator($path);
        // collect all matching sub directories and get all the backup files
        if ($depth < $this->target->countChangingPathElements()) {
            foreach ($dirIterator as $file) {
                if ($file->isDot()) {
                    continue;
                }
                // TODO: match directory against dir-regex Target::getChangingPathElements
                if ($file->isDir()) {
                    $this->collect($file->getPathname(), $depth + 1);
                }
            }
        } else {
            // create regex to match only created backup files
            $fileRegex = Str::datePlaceholdersToRegex($this->target->getFilenameRaw());
            /** @var \SplFileInfo $file */
            foreach ($dirIterator as $i => $file) {
                if ($file->isDir()) {
                    continue;
                }
                // skip currently created backup
                if ($file->getPathname() == $this->target->getPathname()) {
                    continue;
                }
                if (preg_match('#' . $fileRegex . '#i', $file->getFilename())) {
                    $index = date('YmdHis', $file->getMTime()) . '-' . $i . '-' . $file->getPathname();
                    $this->files[$index] = new File($file->getFileInfo());
                }
            }
        }
    }

    /**
     * Check if the iterated file is part of a valid target path.
     *
     * @param \SplFileInfo $file
     * @param  int         $depth
     * @return bool
     */
    protected function isValidDirectory(SplFileInfo $file, $depth)
    {
        return $file->isDir() && $this->isMatchingDirectory($file->getBasename(), $depth);
    }

    /**
     * Does a directory match the respective target path.
     *
     * @param  string $dir
     * @param  int    $depth
     * @return bool
     */
    protected function isMatchingDirectory($dir, $depth)
    {
        $dirTarget = Arr::getValue($this->target->getChangingPathElements(), $depth);
        $dirRegex  = Str::datePlaceholdersToRegex($dirTarget);
        return preg_match('#' . $dirRegex . '#i', $dir);
    }
}