PhpTaskman\Core\Taskman

Complexity

Total Complexity

7

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Test Coverage

Coverage

31.58%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	createConfiguration()	0	21	2
A	createContainer()	0	17	2
A	getComposerFromDirectory()	0	3	1
A	createDefaultRunner()	0	5	1
A	createDefaultApplication()	0	23	1

<?php

declare(strict_types = 1);

namespace PhpTaskman\Core;

use Composer\Autoload\ClassLoader;
use League\Container\Container;
use League\Container\ContainerInterface;
use PhpTaskman\Core\Contract\ComposerAwareInterface;
use PhpTaskman\Core\Services\Composer;
use Robo\Application;
use Robo\Config\Config;
use Robo\Robo;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Class Taskman.
 */
final class Taskman
{
    public const APPLICATION_NAME = 'Taskman';
    public const VERSION = 'dev-master';

    /**
     * Create default configuration.
     *
     * @param null|mixed $workingDir
     * @param mixed $paths
     *
     * @return Config
     */
    public static function createConfiguration($paths, $workingDir = null)
    {
        $workingDir = $workingDir ?? \getcwd();

        // Create a default configuration.
        $config = Robo::createConfiguration($paths);

        // Set the variable working_dir.
        if (false === $workingDir = \realpath($workingDir)) {
            return $config;
        }

        $config->set('taskman.working_dir', \realpath($workingDir));

        // Load the configuration.
        Robo::loadConfiguration(
            \PhpTaskman\Core\Config\Config::findFilesToIncludeInConfiguration($workingDir),
            $config
        );

        return $config;
    }

    /**
     * Create and configure container.
     *
     * @param InputInterface $input
     * @param OutputInterface $output
     * @param Application $application
     * @param Config $config
     * @param ClassLoader $classLoader
     *
     * @return Container|\League\Container\ContainerInterface
     */
    public static function createContainer(
        InputInterface $input,
        OutputInterface $output,
        Application $application,
        Config $config,
        ClassLoader $classLoader
    ) {
        $container = Robo::createDefaultContainer($input, $output, $application, $config, $classLoader);
        $container->get('commandFactory')->setIncludeAllPublicMethods(false);
        $container->share('taskman.composer', Composer::class)->withArgument(\getcwd());

        // Add service inflectors.
        if (null !== $service = $container->inflector(ComposerAwareInterface::class)) {
            $service->invokeMethod('setComposer', ['taskman.composer']);
        }

        return $container;
    }

    /**
     * @param null|string $appName
     * @param null|string $appVersion
     * @param null|string $workingDir
     *
     * @return Application
     */
    public static function createDefaultApplication($appName = null, $appVersion = null, $workingDir = null)
    {
        $workingDir = $workingDir ?? \getcwd();
        $appName = $appName ?? self::APPLICATION_NAME;
        $appVersion = $appVersion ?? self::VERSION;

        $app = Robo::createDefaultApplication($appName, $appVersion);

        $app
            ->getDefinition()
            ->addOption(
                new InputOption(
                    '--working-dir',
                    null,
                    InputOption::VALUE_REQUIRED,
                    'Working directory, defaults to current working directory.',
                    \realpath($workingDir)
                )
            );

        $app->setAutoExit(false);

        return $app;
    }

    /**
     * @param ContainerInterface $container
     *
     * @return \Robo\Runner
     */
    public static function createDefaultRunner(ContainerInterface $container)
    {
        return (new \Robo\Runner())
            ->setRelativePluginNamespace('Robo\Plugin')
            ->setContainer($container);
    }

    /**
     * @param string $path
     *   The directory
     *
     * @return Composer
     *   The composer object.
     */
    public static function getComposerFromDirectory($path)
    {
        return new Composer($path);
    }
}