ConsoleHelpers\SVNBuddy\Command\LogCommand::execute()

Complexity

Conditions	21
Paths	4592

Size

Total Lines	138
Code Lines	79

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	462

Importance

Changes	12
Bugs	0	Features	0

<?php
	protected function execute(InputInterface $input, OutputInterface $output)
	{
		$searching_start = microtime(true);
		$bugs = $this->getList($this->io->getOption('bugs'));

It seems like $this->io->getOption('bugs') can also be of type string[]; however, parameter $string of ConsoleHelpers\SVNBuddy\Command\AbstractCommand::getList() does only seem to accept string, maybe add an additional type check?

		$revisions = $this->getList($this->io->getOption('revisions'));

		$missing_revisions = array();
		$revisions_by_path = $this->getRevisionsByPath();

		if ( $revisions || $bugs ) {

The expression $revisions of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

The expression $bugs of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			if ( $revisions ) {

The expression $revisions of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

				$revisions = $this->_revisionListParser->expandRanges($revisions);

				// Don't check missing revisions from bugs, because they can affect different repository paths.
				$missing_revisions = array_diff($revisions, $revisions_by_path);
			}

			if ( $bugs ) {

The expression $bugs of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

				$revisions_from_bugs = $this->_revisionLog->find('bugs', $bugs);

				if ( !$revisions_from_bugs ) {

The expression $revisions_from_bugs of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

					throw new CommandException('Specified bugs aren\'t mentioned in any of revisions');
				}

				$revisions = array_merge($revisions, $revisions_from_bugs);
			}

			// Only show revisions on given path.
			$revisions_by_path = array_intersect($revisions_by_path, $revisions);
		}

		$merged_by = $this->getList($this->io->getOption('merged-by'));

		if ( $merged_by ) {

The expression $merged_by of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			$merged_by = $this->_revisionListParser->expandRanges($merged_by);
			$revisions_by_path = $this->_revisionLog->find('merges', $merged_by);
		}

		if ( $this->io->getOption('merges') ) {
			$revisions_by_path = array_intersect($revisions_by_path, $this->_revisionLog->find('merges', 'all_merges'));
		}
		elseif ( $this->io->getOption('no-merges') ) {
			$revisions_by_path = array_diff($revisions_by_path, $this->_revisionLog->find('merges', 'all_merges'));
		}

		if ( $this->io->getOption('merged') ) {
			$revisions_by_path = array_intersect($revisions_by_path, $this->_revisionLog->find('merges', 'all_merged'));
		}
		elseif ( $this->io->getOption('not-merged') ) {
			$revisions_by_path = array_diff($revisions_by_path, $this->_revisionLog->find('merges', 'all_merged'));
		}

		$action = $this->io->getOption('action');

		if ( $action ) {
			if ( !in_array($action, $this->getAllActions()) ) {
				throw new CommandException('The "' . $action . '" action is unknown.');

Are you sure $action of type string|string[]|true can be used in concatenation?

			}

			$revisions_by_path = array_intersect(
				$revisions_by_path,
				$this->_revisionLog->find('paths', 'action:' . $action)
			);
		}

		$kind = $this->io->getOption('kind');

		if ( $kind ) {
			if ( !in_array($kind, $this->getAllKinds()) ) {
				throw new CommandException('The "' . $kind . '" kind is unknown.');

Are you sure $kind of type string|string[]|true can be used in concatenation?

			}

			$revisions_by_path = array_intersect(
				$revisions_by_path,
				$this->_revisionLog->find('paths', 'kind:' . $kind)
			);
		}

		$author = $this->io->getOption('author');

		if ( $author ) {
			$revisions_by_path = array_intersect(
				$revisions_by_path,
				$this->_revisionLog->find('summary', 'author:' . $author)
			);
		}

		if ( $missing_revisions ) {
			throw new CommandException($this->getMissingRevisionsErrorMessage($missing_revisions));
		}
		elseif ( !$revisions_by_path ) {

The expression $revisions_by_path of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

			throw new CommandException('No matching revisions found.');
		}

		rsort($revisions_by_path, SORT_NUMERIC);

		if ( $bugs || $revisions ) {

The expression $revisions of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

The expression $bugs of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			// Don't limit revisions, when provided explicitly by user.
			$revisions_by_path_with_limit = $revisions_by_path;
		}
		else {
			// Apply limit only, when no explicit bugs/revisions are set.
			$revisions_by_path_with_limit = array_slice($revisions_by_path, 0, $this->getMaxCount());
		}

		$revisions_by_path_count = count($revisions_by_path);
		$revisions_by_path_with_limit_count = count($revisions_by_path_with_limit);

		if ( $revisions_by_path_with_limit_count === $revisions_by_path_count ) {
			$this->io->writeln(sprintf(
				' * Showing <info>%d</info> revision(-s) in %s:',
				$revisions_by_path_with_limit_count,
				$this->getRevisionLogIdentifier()
			));
		}
		else {
			$this->io->writeln(sprintf(
				' * Showing <info>%d</info> of <info>%d</info> revision(-s) in %s:',
				$revisions_by_path_with_limit_count,
				$revisions_by_path_count,
				$this->getRevisionLogIdentifier()
			));
		}

		$searching_duration = microtime(true) - $searching_start;

		$printing_start = microtime(true);
		$this->printRevisions($revisions_by_path_with_limit);
		$printing_duration = microtime(true) - $printing_start;

		$debug_info = 'Generation Time: <info>' . round($searching_duration + $printing_duration, 2) . 's</info>';
		$debug_info .= ' (';
		$debug_info .= 'searching: <info>' . round($searching_duration, 2) . 's</info>;';
		$debug_info .= ' printing: <info>' . round($printing_duration, 2) . 's</info>';
		$debug_info .= ').';

		$this->io->writeln(
			$debug_info
		);