PHPoole\Command\AbstractCommand

Complexity

Total Complexity

33

Size/Duplication

Total Lines	257
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	wl()	0	4	1
A	wlAnnonce()	0	4	1
A	wlDone()	0	4	1
A	wlAlert()	0	4	1
A	wlError()	0	4	1
A	__invoke()	0	22	4
	processCommand()	0	1	?
A	getConsole()	0	4	1
A	getRoute()	0	4	1
A	getPath()	0	4	1
A	createProgressBar()	0	17	3
A	getProgressBar()	0	4	1
A	printProgressBar()	0	9	2
B	getPHPoole()	0	30	6
B	messageCallback()	0	30	9

<?php
/*
 * This file is part of the PHPoole package.
 *
 * Copyright (c) Arnaud Ligny <arnaud@ligny.org>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace PHPoole\Command;

use PHPoole\PHPoole;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;
use Zend\Console\Adapter\AdapterInterface as Console;
use Zend\Console\ColorInterface as Color;
use Zend\Console\Prompt\Confirm;
use Zend\ProgressBar\ProgressBar;
use ZF\Console\Route;

abstract class AbstractCommand
{
    const CONFIG_FILE = 'phpoole.yml';

    /**
     * @var Console
     */
    protected $console;
    /**
     * @var Route
     */
    protected $route;
    /**
     * @var string
     */
    protected $path;
    /**
     * @var PHPoole
     */
    protected $phpoole;
    /**
     * @var Filesystem
     */
    protected $fs;
    /**
     * @var ProgressBar
     */
    protected $progressBar = null;
    /**
     * @var int
     */
    protected $progressBarMax = 0;
    /**
     * @var bool
     */
    protected $verbose = false;
    /**
     * @var bool
     */
    protected $quiet = false;

    /**
     * Start command processing.
     *
     * @param Route   $route
     * @param Console $console
     *
     * @return mixed
     */
    public function __invoke(Route $route, Console $console)
    {
        $this->route = $route;
        $this->console = $console;
        $this->fs = new Filesystem();

        $this->path = $this->route->getMatchedParam('path', getcwd());

        if (realpath($this->path) === false) {
            if ($this->getRoute()->getName() != 'new') {
                throw new \Exception('Invalid <path> provided!');
            }
            if (!Confirm::prompt('The provided <path> doesn\'t exist. Do you want to create it? [y/n]', 'y', 'n')) {
                exit(0);
            }
            $this->fs->mkdir($this->path);
        }
        $this->path = realpath($this->path);
        $this->path = str_replace(DIRECTORY_SEPARATOR, '/', $this->path);

        return $this->processCommand();
    }

    /**
     * Process the command.
     */
    abstract public function processCommand();

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    /**
     * @return Console
     */
    public function getConsole()
    {
        return $this->console;
    }

    /**
     * @return Route
     */
    public function getRoute()
    {
        return $this->route;
    }

    /**
     * @return string
     */
    public function getPath()
    {
        return $this->path;
    }

    /**
     * @param int $start
     * @param int $max
     *
     * @return ProgressBar
     */
    protected function createProgressBar($start, $max)
    {
        if ($this->progressBar === null || $max != $this->progressBarMax) {
            $this->progressBarMax = $max;
            $adapter = new \Zend\ProgressBar\Adapter\Console([
                'elements' => [
                    \Zend\ProgressBar\Adapter\Console::ELEMENT_PERCENT,
                    \Zend\ProgressBar\Adapter\Console::ELEMENT_BAR,
                    \Zend\ProgressBar\Adapter\Console::ELEMENT_TEXT,
                ],
                'textWidth' => 30,
            ]);
            $this->progressBar = new ProgressBar($adapter, $start, $max);
        }

        return $this->progressBar;
    }

    /**
     * @return ProgressBar
     */
    protected function getProgressBar()
    {
        return $this->progressBar;
    }

    /**
     * Print progress bar.
     */
    protected function printProgressBar($itemsCount, $itemsMax, $message)
    {
        $this->createProgressBar(0, $itemsMax);
        $this->getProgressBar()->update($itemsCount, "$message");
        if ($itemsCount == $itemsMax) {
            $this->getProgressBar()->update($itemsCount, "[$itemsCount/$itemsMax]");
            $this->getProgressBar()->finish();
        }
    }

    /**
     * @param array $config
     * @param array $options
     *
     * @return PHPoole
     */
    public function getPHPoole(
        array $config = ['debug' => false],
        array $options = ['verbosity' => PHPoole::VERBOSITY_NORMAL])
    {
        if (!file_exists($this->getPath().'/'.self::CONFIG_FILE)) {
            throw new \Exception(sprintf('Config file not found in "%s"!', $this->getPath()));
        }
        // verbosity: verbose
        if ($options['verbosity'] == PHPoole::VERBOSITY_VERBOSE) {
            $this->verbose = true;
        }
        // verbosity: quiet
        if ($options['verbosity'] == PHPoole::VERBOSITY_QUIET) {
            $this->quiet = true;
        }

        try {
            $configFile = Yaml::parse(file_get_contents($this->getPath().'/'.self::CONFIG_FILE));
            $config = array_replace_recursive($configFile, $config);
            $this->phpoole = (new PHPoole($config, $this->messageCallback()))
                ->setSourceDir($this->getPath())
                ->setDestinationDir($this->getPath());
        } catch (ParseException $e) {
            throw new \Exception(sprintf('Config file parse error: %s', $e->getMessage()));
        } catch (\Exception $e) {
            throw new \Exception(sprintf($e->getMessage()));
        }

        return $this->phpoole;
    }

    /**
     * Custom message callback function.
     */
    public function messageCallback()
    {
        return function ($code, $message = '', $itemsCount = 0, $itemsMax = 0) {
            if ($this->quiet) {
                return;
            } else {
                if (strpos($code, '_PROGRESS') !== false) {
                    if ($this->verbose) {
                        if ($itemsCount > 0) {
                            $this->wlDone(sprintf('(%u/%u) %s', $itemsCount, $itemsMax, $message));
                            return;
                        }
                        $this->wlDone("$message");
                    } else {
                        if (isset($itemsCount) && $itemsMax > 0) {
                            $this->printProgressBar($itemsCount, $itemsMax, $message);
                        } else {
                            $this->wl($message);
                        }
                    }
                } elseif (strpos($code, '_ERROR') !== false) {
                    $this->wlError($message);
                } elseif ($code == 'TIME') {
                    $this->wl($message);
                } else {
                    $this->wlAnnonce($message);
                }
            }
        };
    }

    /**
     * @param string $text
     */
    public function wl($text)
    {
        $this->console->writeLine($text);
    }

    /**
     * @param string $text
     */
    public function wlAnnonce($text)
    {
        $this->console->writeLine($text, Color::WHITE);
    }

    /**
     * @param string $text
     */
    public function wlDone($text)
    {
        $this->console->writeLine($text, Color::GREEN);
    }

    /**
     * @param string $text
     */
    public function wlAlert($text)
    {
        $this->console->writeLine($text, Color::YELLOW);
    }

    /**
     * @param string $text
     */
    public function wlError($text)
    {
        $this->console->writeLine($text, Color::RED);
    }
}