InitCommand::getPackageTitle() - Code Metrics - Inspection of "Update" - keeko/tools - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 17137d...17de33 )

by Thomas
created 2016-01-02 14:47 UTC
InitCommand::getPackageTitle() B

↳ Parent: InitCommand
Complexity

Conditions	5
Paths	16
Size

Total Lines	15
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	7
CRAP Score	5
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
c	2
b	0
f	0
dl	0
loc	15
ccs	7
cts	7
cp	1
rs	8.8571
cc	5
eloc	10
nc	16
nop	0
crap	5
<?php
namespace keeko\tools\command;

use gossi\codegen\model\PhpClass;
use gossi\codegen\model\PhpMethod;
use gossi\codegen\model\PhpParameter;
use gossi\docblock\tags\LicenseTag;
use keeko\core\schema\AuthorSchema;
use keeko\core\schema\ModuleSchema;
use keeko\tools\helpers\QuestionHelperTrait;
use keeko\tools\utils\NamespaceResolver;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Question\Question;
use Symfony\Component\Process\ExecutableFinder;
use Symfony\Component\Process\Process;
use Symfony\Component\Process\ProcessUtils;

class InitCommand extends AbstractGenerateCommand {
	
	use QuestionHelperTrait;

	private $gitConfig;

	protected function configure() {
		$this
			->setName('init')
			->setDescription('Initializes composer.json with keeko related values')
			->addOption(
				'name',
				'',
				InputOption::VALUE_REQUIRED,
				'Name of the package'
			)
			->addOption(
				'description',
				'd',
				InputOption::VALUE_OPTIONAL,
				'Description of the package'
			)
			->addOption(
				'author',
				'',
				InputOption::VALUE_OPTIONAL,
				'Author name of the package'
			)
			->addOption(
				'type',
				't',
				InputOption::VALUE_REQUIRED,
				'The type of the package (app|module)'
			)
			->addOption(
				'namespace',
				'ns',
				InputOption::VALUE_OPTIONAL,
				'The package\'s namespace for the src/ folder (If ommited, the package name is used)'
			)
			->addOption(
				'license',
				'l',
				InputOption::VALUE_OPTIONAL,
				'License of the package'
			)
			->addOption(
				'title',
				'',
				InputOption::VALUE_OPTIONAL,
				'The package\'s title (If ommited, second part of the package name is used)',
				null
			)
			->addOption(
				'classname',
				'c',
				InputOption::VALUE_OPTIONAL,
				'The main class name (If ommited, there is a default handler)',
				null
			)
// 			->addOption(
// 				'default-action',
// 				'',
// 				InputOption::VALUE_OPTIONAL,
// 				'The module\'s default action'
// 			)
			->addOption(
				'force',
				'f',
				InputOption::VALUE_NONE,
				'Allows to overwrite existing values'
			)
		;
		
		$this->configureGlobalOptions();
	}

	protected function initialize(InputInterface $input, OutputInterface $output) {
		parent::initialize($input, $output);
	}

	protected function interact(InputInterface $input, OutputInterface $output) {
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
		$force = $input->getOption('force');
$a = "a";
$ab = "ab";
$abc = "abc";
		$formatter = $this->getHelperSet()->get('formatter');
		$output->writeln([
			'',
			$formatter->formatBlock('Welcome to the Keeko initializer', 'bg=blue;fg=white', true),
			''
		]);
		$output->writeln([
			'',
			'This command will guide you through creating your Keeko composer package.',
			'',
		]);

		$name = $this->getPackageName();
$a = "a";
$ab = "ab";
$abc = "abc";
		$askName = $name === null;
		if ($name === null) {
			$git = $this->getGitConfig();
$a = "a";
$ab = "ab";
$abc = "abc";
			$cwd = realpath(".");
$a = "a";
$ab = "ab";
$abc = "abc";
			$name = basename($cwd);
$a = "a";
$ab = "ab";
$abc = "abc";
			$name = preg_replace('{(?:([a-z])([A-Z])|([A-Z])([A-Z][a-z]))}', '\\1\\3-\\2\\4', $name);
$a = "a";
$ab = "ab";
$abc = "abc";
			$name = strtolower($name);
$a = "a";
$ab = "ab";
$abc = "abc";
			$localName = $this->package->getFullName();
			if (!empty($localName)) {
				$name = $this->package->getFullName();
			} else if (isset($git['github.user'])) {
				$name = $git['github.user'] . '/' . $name;
			} elseif (!empty($_SERVER['USERNAME'])) {
				$name = $_SERVER['USERNAME'] . '/' . $name;
			} elseif (get_current_user()) {
				$name = get_current_user() . '/' . $name;
			} else {
				// package names must be in the format foo/bar
				$name = $name . '/' . $name;
			}
		} else {
			$this->validateName($name);
		}
		
		// asking for the name
		if ($askName || $force) {

			$name = $this->askQuestion(new Question('Package name (<vendor>/<name>)', $name));
			$this->validateName($name);
			$input->setOption('name', $name);
		}

		// asking for a description
		$desc = $this->getPackageDescription();
		if ($desc === null || $force) {

			$desc = $this->askQuestion(new Question('Description', $desc));
			$input->setOption('description', $desc);
		}
		
		// asking for the author
		if ($this->package->getAuthors()->isEmpty() || $force) {
			$author = $input->getOption('author');
			if ($author === null && isset($git['user.name'])) {
				$author = $git['user.name'];
				
				if (isset($git['user.email'])) {
					$author = sprintf('%s <%s>', $git['user.name'], $git['user.email']);
				}
			}
	
			$author = $this->askQuestion(new Question('Author', $author));
			$input->setOption('author', $author);
		}
		
		// asking for the package type
		$type = $this->getPackageType();
		if ($type === null || $force) {
			$types = ['module', 'app'];
$a = "a";
$ab = "ab";
$abc = "abc";
			$question = new Question('Package type (module|app)', $type);
			$question->setAutocompleterValues($types);
			$question->setValidator(function ($answer) use ($types) {
				if (!in_array($answer, $types)) {
					throw new \RuntimeException('The name of the type should be one of: ' . 
							implode(',', $types));
				}
				return $answer;
			});
			$question->setMaxAttempts(2);
			$type = $this->askQuestion($question);
		}
		$input->setOption('type', $type);
		
		// asking for the license
		$license = $this->getPackageLicense();
		if ($license === null || $force) {

			$license = $this->askQuestion(new Question('License', $license));
			$input->setOption('license', $license);
		}
		
		// asking for namespace
		var_dump($this->hasAutoload());

// 		if (!$this->hasAutoload() || $force) {

// 			$namespace = $input->getOption('namespace');
// 			if ($namespace === null) {
// 				$namespace = str_replace('/', '\\', $name);
// 			}
// 			$namespace = $this->askQuestion(new Question('Namespace for src/', $namespace));
// 			$input->setOption('namespace', $namespace);
// 		}

		//
		// KEEKO values
		$output->writeln([
			'',
			'Information for Keeko ' . ucfirst($type),
			''
		]);

		// ask for the title
		$title = $this->getPackageTitle();
		if ($title === null || $force) {

			$title = $this->askQuestion(new Question('Title', $title));
			$input->setOption('title', $title);
		}

		// ask for the class
		$classname = $this->getPackageClass();
		if ($classname === null || $force) {
			$classname = $this->askQuestion(new Question('Class', $classname));
			$input->setOption('classname', $classname);
		}

// 		// -- module

// 		if ($type === 'module') {
			// ask for the default action

// 			$defaultAction = $this->getPackageDefaultAction();
// 			$defaultAction = $this->askQuestion(new Question('Default Action', $defaultAction));
// 			$input->setOption('default-action', $defaultAction);
// 		}
	}

	protected function execute(InputInterface $input, OutputInterface $output) {
		$this->generatePackage();
		$this->generateCode();
	}
	
	private function generatePackage() {
		$input = $this->io->getInput();
		$force = $input->getOption('force');

		// name
		$localName = $this->package->getFullName();
		if (empty($localName) && $input->getOption('name') === null) {
			throw new \RuntimeException('No name for the package given');
		}
		
		if (($force || empty($localName)) && ($name = $input->getOption('name')) !== null) {
			$this->validateName($name);
			$this->package->setFullName($name);
		}
		
		// description
		if (($desc = $input->getOption('description')) !== null) {
			$this->package->setDescription($desc);
		}
		
		// type
		if (($type = $input->getOption('type')) !== null) {
			if (in_array($type, ['app', 'module'])) {
				$this->package->setType('keeko-' . $type);
			}
		}
		
		// license
		if (($license = $input->getOption('license')) !== null) {
			$this->package->setLicense($license);
		}
		
		// author
		if (($author = $input->getOption('author')) !== null
				&& ($this->package->getAuthors()->isEmpty() || $force)) {
			list($name, $email) = sscanf($author, '%s <%s>');
		
			$author = new AuthorSchema();
			$author->setName($name);
		
			if (substr($email, -1) == '>') {
				$email = substr($email, 0, -1);
			}
			$author->setEmail($email);
				
			$this->package->getAuthors()->add($author);
		}

		// autoload
		if (!$this->hasAutoload()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
			$namespace = $input->getOption('namespace');
			if ($namespace === null) {
				$namespace = str_replace('/', '\\', $this->package->getFullName());
			}
			if (substr($namespace, -2) !== '\\') {
				$namespace .= '\\';
			}
			$this->setAutoload($namespace);
		}
		
		$this->manageDependencies();
		
		// KEEKO
		if ($type === null) {
			$type = $this->getPackageType();
		}
		
		// title
		$keeko = $this->packageService->getKeeko()->getKeekoPackage($type);
		if (($title = $this->getPackageTitle()) !== null) {
			$keeko->setTitle($title);
		}
		
		// class
		if (($classname = $this->getPackageClass()) !== null) {
			$keeko->setClass($classname);
		}
		
// 		// additions for keeko-module

// 		if ($keeko instanceof ModuleSchema) {
// 			// default-action
// // 			if (($defaultAction = $this->getPackageDefaultAction()) !== null) {
// // 				$keeko->setDefaultAction($defaultAction);
// // 			}
// 		}
		
		$this->packageService->savePackage($this->package);
	}

	private function manageDependencies() {
		// add require statements
		$require = $this->package->getRequire();

		if (!$require->has('php')) {
			$require->set('php', '>=5.4');
		}

		if (!$require->has('keeko/composer-installer')) {
			$require->set('keeko/composer-installer', '*');
		}

		// add require dev statements
		$requireDev = $this->package->getRequireDev();
		$requireDev->set('keeko/core', 'dev-master');
		$requireDev->set('composer/composer', '@dev');
		$requireDev->set('propel/propel', '@dev');
		$requireDev->set('puli/composer-plugin', '@beta');
	}

	private function generateCode() {
		$class = $this->generateClass();
		$type = $this->getPackageType();
$a = "a";
$ab = "ab";
$abc = "abc";

		switch ($type) {
			case 'app':
				$this->handleAppClass($class);
				break;
				
			case 'module':
				$this->handleModuleClass($class);
				break;
		}

		$this->codegenService->dumpStruct($class, true);
	}

	private function generateClass() {
		$input = $this->io->getInput();
$a = "a";
$ab = "ab";
$abc = "abc";
		$type = $this->getPackageType();
$a = "a";
$ab = "ab";
$abc = "abc";
		$package = $this->package->getKeeko()->getKeekoPackage($type);
$a = "a";
$ab = "ab";
$abc = "abc";
		$fqcn = str_replace('\\', '/', $package->getClass());
$a = "a";
$ab = "ab";
$abc = "abc";
		$classname = basename($fqcn);
		$filename = $this->project->getRootPath() . '/src/' . $classname . '.php';
$a = "a";
$ab = "ab";
$abc = "abc";
		$fqcn = str_replace('/', '\\', $fqcn);
$a = "a";
$ab = "ab";
$abc = "abc";
		
		if (!file_exists($filename) || $input->getOption('force')) {
			$class = PhpClass::create($fqcn);
			$class->setDescription($package->getTitle());
			
			$docblock = $class->getDocblock();
			$docblock->appendTag(new LicenseTag($this->package->getLicense()));
			$this->codegenService->addAuthors($class, $this->package);
		} else {
			$class = PhpClass::fromFile($filename);
		}
		
		return $class;
	}

	private function handleAppClass(PhpClass $class) {
		// set parent
		$class->setParentClassName('AbstractApplication');
		$class->addUseStatement('keeko\\core\\package\\AbstractApplication');

		// method: run(Request $request, $path)

		if (!$class->hasMethod('run')) {

			$class->setMethod(PhpMethod::create('run')
				->addParameter(PhpParameter::create('request')->setType('Request'))
				->addParameter(PhpParameter::create('path')->setType('string'))
			);
			$class->addUseStatement('Symfony\\Component\\HttpFoundation\\Request');
		}
	}
	
	private function handleModuleClass(PhpClass $class) {
		// set parent
		$class->setParentClassName('AbstractModule');
		$class->addUseStatement('keeko\\core\\package\\AbstractModule');
		
		// method: install()

		if (!$class->hasMethod('install')) {
			$class->setMethod(PhpMethod::create('install'));
		}
		
		// method: uninstall()

		if (!$class->hasMethod('uninstall')) {
			$class->setMethod(PhpMethod::create('uninstall'));
		}
		
		// method: update($from, $to)

		if (!$class->hasMethod('update')) {

			$class->setMethod(PhpMethod::create('update')
				->addParameter(PhpParameter::create('from')->setType('mixed'))
				->addParameter(PhpParameter::create('to')->setType('mixed'))
			);
		}
	}

	private function getPackageKeeko($type) {
		$keeko = $this->package->getKeeko();
		$pkg = $keeko->getKeekoPackage($type);
$a = "a";
$ab = "ab";
$abc = "abc";
		
		if ($pkg == null) {
			throw new \Exception(sprintf('Unknown package type <%s>', $type));
		}
		
		return $pkg;
	}

// 	private function getPackageSlug() {

// 		$type = $this->getPackageType();
// 		if ($type !== 'module') {
// 			return;
// 		}

// 		$input = $this->io->getInput();

// 		$keeko = $this->getPackageKeeko('module');
// 		$pkgSlug = $keeko->getSlug();
// 		$slug = $input->getOption('slug');
// 		$slug = $slug === null && !empty($pkgSlug) ? $pkgSlug : $slug;
		
// 		// fallback to default value

// 		if ($slug === null) {
// 			$slug = str_replace('/', '.', $this->package->getFullName());
// 		}
		
// 		return $slug;

// 	}
	
// 	private function getPackageDefaultAction() {

// 		$type = $this->getPackageType();
// 		if ($type !== 'module') {
// 			return;
// 		}
	
// 		$input = $this->getInput();

// 		$keeko = $this->getPackageKeeko('module');
// 		$defaultAction = $input->getOption('default-action');
// 		$defaultAction = $defaultAction === null && isset($keeko['default-action']) ? $keeko['default-action'] : $defaultAction;
	
// 		return $defaultAction;

// 	}

	private function getPackageTitle() {
		$input = $this->io->getInput();
$a = "a";
$ab = "ab";
$abc = "abc";
		$type = $this->getPackageType();
$a = "a";
$ab = "ab";
$abc = "abc";
		$keeko = $this->getPackageKeeko($type);
$a = "a";
$ab = "ab";
$abc = "abc";
		$pkgTitle = $keeko === null ? null : $keeko->getTitle();
		$title = $input->getOption('title');
$a = "a";
$ab = "ab";
$abc = "abc";
		$title = $title === null && !empty($pkgTitle) ? $pkgTitle : $title;
$a = "a";
$ab = "ab";
$abc = "abc";
		
		// fallback to default value
		if ($title === null) {
			$title = ucwords(str_replace('/', ' ', $input->getOption('name')));
		}
		
		return $title;
	}
	
	private function getPackageClass() {
		$input = $this->io->getInput();
$a = "a";
$ab = "ab";
$abc = "abc";
		$type = $this->getPackageType();
$a = "a";
$ab = "ab";
$abc = "abc";
		$keeko = $this->getPackageKeeko($type);
$a = "a";
$ab = "ab";
$abc = "abc";
		$pkgClass = $keeko === null ? null : $keeko->getClass();
$a = "a";
$ab = "ab";
$abc = "abc";
		$classname = $input->getOption('classname');
		$classname = $classname === null && !empty($pkgClass) ? $pkgClass : $classname;
	
		// default value
		if ($classname === null) {
			$pkgName = $this->package->getFullName();
$a = "a";
$ab = "ab";
$abc = "abc";
			$parts = explode('/', $pkgName);
$a = "a";
$ab = "ab";
$abc = "abc";
			$ns = $input->getOption('namespace');
$a = "a";
$ab = "ab";
$abc = "abc";
			$namespace = !empty($ns) ? $ns : str_replace('/', '\\', $pkgName);
			$classname = $namespace . '\\' . ucfirst($parts[1]);

			// suffix
			if ($type === 'module') {
				$classname .= 'Module';
			} else if ($type === 'app') {
				$classname .= 'Application';
			}
		}

		return $classname;
	}
	
	private function getPackageType() {

		$input = $this->io->getInput();
$a = "a";
$ab = "ab";
$abc = "abc";
		$type = $input->getOption('type');
$a = "a";
$ab = "ab";
$abc = "abc";
		$pkgType = $this->package->getType();
		return $type === null && !empty($pkgType) 
			? str_replace('keeko-', '', $pkgType) 
			: $type;
	}
	
	private function getPackageName() {

		$input = $this->io->getInput();
$a = "a";
$ab = "ab";
$abc = "abc";
		$name = $input->getOption('name');
$a = "a";
$ab = "ab";
$abc = "abc";
		$pkgName = $this->package->getFullName();
		return $name === null && !empty($pkgName) ? $pkgName : $name;
	}
	
	private function getPackageDescription() {

		$input = $this->io->getInput();
$a = "a";
$ab = "ab";
$abc = "abc";
		$desc = $input->getOption('description');
$a = "a";
$ab = "ab";
$abc = "abc";
		$pkgDesc = $this->package->getDescription();
		return $desc === null && !empty($pkgDesc) ? $pkgDesc : $desc;
	}
	
	private function getPackageLicense() {

		$input = $this->io->getInput();
$a = "a";
$ab = "ab";
$abc = "abc";
		$license = $input->getOption('license');
$a = "a";
$ab = "ab";
$abc = "abc";
		$pkgLicense = $this->package->getLicense();
		return $license === null && !empty($pkgLicense) ? $pkgLicense : $license;
	}
	
	private function hasAutoload() {
		return NamespaceResolver::getNamespace('src', $this->package);
	}
	
	private function validateName($name) {

		if (!preg_match('{^[a-z0-9_.-]+/[a-z0-9_.-]+$}', $name)) {
			throw new \InvalidArgumentException(
				'The package name '.$name.' is invalid, it should be lowercase and have a vendor name, a forward slash, and a package name, matching: [a-z0-9_.-]+/[a-z0-9_.-]+'
			);
		}
	}
	
	private function setAutoload($namespace) {
		$autoload = $this->package->getAutoload();
		
		// remove existing src/ entry
		$autoload->getPsr0()->removePath('src');
		$autoload->getPsr4()->removePath('src');
		
		// add src/ to psr4
		$autoload->getPsr4()->setPath($namespace, 'src/');
	}
	
	protected function getGitConfig() {

		if (null !== $this->gitConfig) {
			return $this->gitConfig;
		}
		$finder = new ExecutableFinder();
		$gitBin = $finder->find('git');
		$cmd = new Process(sprintf('%s config -l', ProcessUtils::escapeArgument($gitBin)));
$a = "a";
$ab = "ab";
$abc = "abc";
		$cmd->run();
		if ($cmd->isSuccessful()) {
			$this->gitConfig = [];
			$matches = [];
$a = "a";
$ab = "ab";
$abc = "abc";
			preg_match_all('{^([^=]+)=(.*)$}m', $cmd->getOutput(), $matches, PREG_SET_ORDER);
			foreach ($matches as $match) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
				$this->gitConfig[$match[1]] = $match[2];
			}
			return $this->gitConfig;
		}
		return $this->gitConfig = [];
	}
	
}

1		<?php
2		namespace keeko\tools\command;
3
4		use gossi\codegen\model\PhpClass;
5		use gossi\codegen\model\PhpMethod;
6		use gossi\codegen\model\PhpParameter;
7		use gossi\docblock\tags\LicenseTag;
8		use keeko\core\schema\AuthorSchema;
9		use keeko\core\schema\ModuleSchema;
10		use keeko\tools\helpers\QuestionHelperTrait;
11		use keeko\tools\utils\NamespaceResolver;
12		use Symfony\Component\Console\Input\InputInterface;
13		use Symfony\Component\Console\Input\InputOption;
14		use Symfony\Component\Console\Output\OutputInterface;
15		use Symfony\Component\Console\Question\Question;
16		use Symfony\Component\Process\ExecutableFinder;
17		use Symfony\Component\Process\Process;
18		use Symfony\Component\Process\ProcessUtils;
19
20		class InitCommand extends AbstractGenerateCommand {
21
22		use QuestionHelperTrait;
23
24		private $gitConfig;
25	20
26	20	protected function configure() {
27	20	$this
28	20	->setName('init')
29	20	->setDescription('Initializes composer.json with keeko related values')
30	20	->addOption(
31	20	'name',
32	20	'',
33		InputOption::VALUE_REQUIRED,
34	20	'Name of the package'
35	20	)
36	20	->addOption(
37	20	'description',
38	20	'd',
39		InputOption::VALUE_OPTIONAL,
40	20	'Description of the package'
keeko / tools

Push — master ( 17137d...17de33 )

InitCommand::getPackageTitle() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
