Webcreate\Conveyor\Task\RemoveTask

Complexity

Total Complexity

19

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

0%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setIo()	0	6	1
C	execute()	0	51	12
B	removeEmptyDirectories()	0	29	5

<?php

namespace Webcreate\Conveyor\Task;

use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Finder\Finder;
use Webcreate\Conveyor\IO\IOInterface;
use Webcreate\Conveyor\Repository\Version;
use Webcreate\Conveyor\Task\Result\ExecuteResult;
use Webcreate\Conveyor\Util\FileCollection;

class RemoveTask extends Task
{
    protected $cwd;

    /**
     * @var IOInterface
     */
    protected $io;

Avoid variables with short names like $io. Configured minimum length is 3.

    /**
     * @param $cwd
     */
    function __construct($cwd)

It is generally recommended to explicitly declare the visibility for methods.

It is recommend to declare an explicit visibility for __construct.

    {
        $this->cwd = $cwd;
    }

    /**
     * @param IOInterface $io
     *
     * @return $this
     */
    public function setIo(IOInterface $io)

Avoid variables with short names like $io. Configured minimum length is 3.

    {
        $this->io = $io;

        return $this;
    }

    /**
     * @param string $target
     * @param Version $version
     *
     * @return ExecuteResult
     */
    public function execute($target, Version $version)

This operation has 432 execution paths which exceeds the configured maximum of 200.

    {
        $filesystem = new Filesystem();

        if ($this->io && !$this->io->isVerbose()) {
            $this->output(sprintf('Removing: <comment>0%%</comment>'));
        }

        $collection = new FileCollection($this->cwd);

        if (!$this->options['files'] && $this->options['exclude']) {
            $collection->add('*');
        }

        foreach ($this->options['files'] as $file) {
            $collection->add($file);
        }

        foreach ($this->options['exclude'] as $file) {
            $collection->remove($file);
        }

        $files = $collection->toArray();

        $total = count($files);
        $i = 0;

        foreach ($files as $file) {
            $filename = sprintf('%s/%s', rtrim($this->cwd, DIRECTORY_SEPARATOR), $file);

            $filesystem->remove($filename);

            if ($this->io && !$this->io->isVerbose()) {
                $this->output(sprintf('Removing: <comment>%d%%</comment>', round(++$i * 100 / $total)));
            } else {
                $this->output(sprintf("Removed %s", $file));
            }

            // remove empty directories
            $this->removeEmptyDirectories($this->cwd, $file);
        }

        if ($this->io && !$this->io->isVerbose()) {
            $this->output(sprintf('Removing: <comment>%d%%</comment>', 100));
        }

        return new ExecuteResult(
            array(),
            $files
        );
    }

    /**
     * Removes empty directories
     *
     * @param $cwd
     * @param $file
     */
    protected function removeEmptyDirectories($cwd, $file)
    {
        $filesystem = new Filesystem();

        $filename = sprintf('%s/%s', rtrim($cwd, DIRECTORY_SEPARATOR), $file);

        while ('.' !== dirname($file)) {
            $file     = dirname($file);

Consider using a different name than the parameter $file. This often makes code more readable.

            $filename = dirname($filename);

            $finder = new Finder();
            $countFiles = $finder
                ->files()
                ->in($filename)
                ->ignoreDotFiles(false)
                ->ignoreVCS(false)
                ->count();

            if ($countFiles === 0) {
                $filesystem->remove($filename);

                if ($this->io && $this->io->isVerbose()) {
                    $this->output(sprintf("Removed %s", $file));
                }
            } else {
                return;
            }
        }
    }
}