keeko\core\installer\AbstractPackageInstaller

Complexity

Total Complexity

6

Size/Duplication

Total Lines	59
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes	7
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
	install()	0	1	?
	update()	0	1	?
	uninstall()	0	1	?
A	updatePackage()	0	15	2
A	getPackageSchema()	0	3	1
A	updateExtensions()	0	12	2

<?php
namespace keeko\core\installer;

use Composer\IO\IOInterface;
use keeko\core\model\Package;
use keeko\core\model\PackageQuery;
use keeko\core\service\ServiceContainer;
use Symfony\Component\EventDispatcher\EventDispatcher;
use keeko\core\schema\KeekoPackageSchema;
use keeko\core\model\ExtensionQuery;
use keeko\core\model\Extension;
use phootwork\json\Json;

abstract class AbstractPackageInstaller {
	
	/** @var ServiceContainer */
	protected $service;
	
	/** @var EventDispatcher */
	protected $dispatcher;
	
	public function __construct(ServiceContainer $service) {
		$this->service = $service;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

		$this->dispatcher = $this->service->getDispatcher();
	}

	/**
	 * Installs a package
	 *
	 * @param IOInterface $io the IOInterface
	 * @param string $packageName
	 * @throws MissingOptionsException when required parameters for the package are missing
	 */
	abstract public function install(IOInterface $io, $packageName);

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.

	abstract public function update(IOInterface $io, $packageName, $from, $to);

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.

	abstract public function uninstall(IOInterface $io, $packageName);

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.

	protected function updatePackage(Package &$model, KeekoPackageSchema $pkg) {
		$packageName = $pkg->getPackage()->getFullName();
		$result = PackageQuery::create()->filterByName($packageName)->count();

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

		$info = $this->service->getPackageManager()->getComposerPackage($packageName);

Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space

		
		if ($result == 0) {
			$model->setTitle($pkg->getTitle());
			$model->setDescription($info->getDescription());
			$model->setName($packageName);
			$model->setInstalledVersion($info->getPrettyVersion());
			$model->save();
		}
		
		$this->updateExtensions($model, $pkg);
	}
	
	protected function getPackageSchema($packageName) {
		return $this->service->getPackageManager()->getPackage($packageName);
	}
	
	protected function updateExtensions(Package &$model, KeekoPackageSchema $pkg) {
		// remove all existing extensions from this package first
		ExtensionQuery::create()->filterByPackage($model)->deleteAll();
		
		// add them one by one
		foreach ($pkg->getExtensions() as $key => $data) {
			$ext = new Extension();
			$ext->setKey($key);
			$ext->setData(Json::encode($data));
			$ext->save();
		}
	}
}