Eccube\Service\Composer\ComposerProcessService

Complexity

Total Complexity

12

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	execRequire()	0	7	1
A	execRemove()	0	7	1
A	runCommand()	0	24	4
A	init()	0	18	2
A	execConfig()	0	4	1
A	configureRepository()	0	4	1
A	foreachRequires()	0	4	1

<?php

/*
 * This file is part of EC-CUBE
 *
 * Copyright(c) LOCKON CO.,LTD. All Rights Reserved.
 *
 * http://www.lockon.co.jp/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Eccube\Service\Composer;

use Doctrine\ORM\EntityManagerInterface;
use Eccube\Common\EccubeConfig;
use Eccube\Entity\BaseInfo;
use Eccube\Exception\PluginException;
use Eccube\Repository\BaseInfoRepository;

/**
 * Class ComposerProcessService
 */
class ComposerProcessService implements ComposerServiceInterface
{
    /**
     * @var EccubeConfig config parameter
     */
    protected $eccubeConfig;

    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;

    private $workingDir;

The property $workingDir is not used and could be removed.

    /**
     * @var ComposerApiService
     */
    private $composerApiService;
    /**
     * @var BaseInfoRepository
     */
    private $baseInfoRepository;

    /**
     * ComposerProcessService constructor.
     *
     * @param EccubeConfig $eccubeConfig
     * @param EntityManagerInterface $entityManager
     * @param ComposerApiService $composerApiService
     */
    public function __construct(EccubeConfig $eccubeConfig, EntityManagerInterface $entityManager, ComposerApiService $composerApiService, BaseInfoRepository $baseInfoRepository)
    {
        $this->eccubeConfig = $eccubeConfig;
        $this->entityManager = $entityManager;
        $this->composerApiService = $composerApiService;
        $this->baseInfoRepository = $baseInfoRepository;
    }

    public function execRequire($packageName, $output = null)
    {
        return $this->runCommand([
            'eccube:composer:require',
            $packageName,
        ], $output);
    }

    public function execRemove($packageName, $output = null)
    {
        return $this->runCommand([
            'eccube:composer:remove',
            $packageName,
        ], $output);
    }

    /**
     * Run command
     *
     * @throws PluginException
     *
     * @param string $command

There is no parameter named $command. Did you maybe mean $commands?

     */
    public function runCommand($commands, $output = null, $init = true)

The parameter $output is not used and could be removed.

    {
        if ($init) {
            $this->init();
        }

        $command = implode(' ', array_merge(['bin/console'], $commands));
        try {
            // Execute command
            $returnValue = -1;
            $output = [];
            exec($command, $output, $returnValue);

            $outputString = implode(PHP_EOL, $output);
            if ($returnValue) {

The expression $returnValue of type integer|null is loosely compared to true; this is ambiguous if the integer can be zero. You might want to explicitly use !== null instead.

                throw new PluginException($outputString);
            }
            log_info(PHP_EOL.$outputString.PHP_EOL);

            return $outputString;
        } catch (\Exception $exception) {
            throw new PluginException($exception->getMessage());
        }
    }

    /**
     * Set init
     *
     * @throws PluginException
     */
    private function init($BaseInfo = null)
    {
//        /**
//         * Mysql lock in transaction
//         *
//         * @see https://dev.mysql.com/doc/refman/5.7/en/lock-tables.html
//         *
//         * @var EntityManagerInterface
//         */
//        $em = $this->entityManager;
//        if ($em->getConnection()->isTransactionActive()) {
//            $em->getConnection()->commit();
//            $em->getConnection()->beginTransaction();
//        }

        $BaseInfo = $BaseInfo ?: $this->baseInfoRepository->get();
        $this->composerApiService->configureRepository($BaseInfo);
    }

    public function execConfig($key, $value = null)
    {
        return $this->composerApiService->execConfig($key, $value);
    }

    public function configureRepository(BaseInfo $BaseInfo)
    {
        return $this->composerApiService->configureRepository($BaseInfo);
    }

    public function foreachRequires($packageName, $version, $callback, $typeFilter = null, $level = 0)
    {
        return $this->composerApiService->foreachRequires($packageName, $version, $callback, $typeFilter, $level);
    }
}