ZenifyCodingStandard\Sniffs\Namespaces\UseInAlphabeticalOrderSniff

Complexity

Total Complexity

21

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

98.21%

Importance

Changes	2
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	4	1
B	process()	0	22	4
C	findAllUseStatements()	0	32	8
B	getUseStatementIncorrectOrderPosition()	0	19	5
A	replaceBackSlashesBySlashes()	0	4	1
A	isUseForNamespaceOrTrait()	0	8	2

<?php

/**
 * This file is part of Zenify
 * Copyright (c) 2012 Tomas Votruba (http://tomasvotruba.cz)
 */

namespace ZenifyCodingStandard\Sniffs\Namespaces;

use PHP_CodeSniffer_File;
use PHP_CodeSniffer_Sniff;


/**
 * Rules:
 * - Use statements should be in alphabetical order
 *
 * @author Mikulas Dite <mikulas@dite.pro>
 * @author Tomas Votruba <tomas.vot@gmail.com>
 */
final class UseInAlphabeticalOrderSniff implements PHP_CodeSniffer_Sniff
{

	/**
	 * @var array
	 */
	private $processedFiles = [];

	/**
	 * @var PHP_CodeSniffer_File
	 */
	private $file;

	/**
	 * @var int
	 */
	private $position;


	/**
	 * {@inheritdoc}
	 */
	public function register()
	{
		return [T_USE];
	}


	/**
	 * {@inheritdoc}
	 */
	public function process(PHP_CodeSniffer_File $file, $position)
	{
		$this->file = $file;
		$this->position = $position;

		if (isset($this->processedFiles[$file->getFilename()])) {
			return;
		}
		$this->processedFiles[$file->getFilename()] = TRUE; // Prevent multiple uses in the same file from entering

		$isClosure = $file->findPrevious([T_CLOSURE], ($position - 1), NULL, FALSE, NULL, TRUE);
		if ($isClosure) {
			return;
		}

		$useStatements = $this->findAllUseStatements();
		$failedIndex = $this->getUseStatementIncorrectOrderPosition($useStatements);
		if ($failedIndex) {

The expression $failedIndex 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.

			$error = 'Use statements should be in alphabetical order';
			$file->addError($error, $failedIndex);
		}
	}


	/**
	 * @return array
	 */
	private function findAllUseStatements()
	{
		$uses = [];
		$next = $this->position;
		while (TRUE) {
			$content = '';
			$end = $this->file->findNext([T_SEMICOLON, T_OPEN_CURLY_BRACKET], $next);
			$useTokens = array_slice($this->file->getTokens(), $next, $end - $next, TRUE);
			$index = NULL;
			foreach ($useTokens as $index => $token) {
				if ($token['code'] === T_STRING || $token['code'] === T_NS_SEPARATOR) {
					$content .= $token['content'];
				}
			}
			// Check for class scoping on use. Traits should be ordered independently.
			$scope = 0;
			if ( ! empty($token['conditions'])) {
				$scope = key($token['conditions']);
			}

			if ($this->isUseForNamespaceOrTrait($next)) {
				$content = $this->replaceBackSlashesBySlashes($content);
				$uses[$scope][$content] = $index;
			}

			$next = $this->file->findNext(T_USE, $end);
			if ( ! $next) {
				break;
			}
		}
		return $uses;
	}


	/**
	 * @return int|NULL
	 */
	private function getUseStatementIncorrectOrderPosition(array $uses)
	{
		foreach ($uses as $scope => $used) {
			$defined = $sorted = array_keys($used);

			natcasesort($sorted);
			$sorted = array_values($sorted);
			if ($sorted === $defined) {
				continue;
			}

			foreach ($defined as $i => $name) {
				if ($name !== $sorted[$i]) {
					return $used[$name];
				}
			}
		}
		return NULL;
	}


	/**
	 * @param string $content
	 * @return string
	 */
	private function replaceBackSlashesBySlashes($content)
	{
		return str_replace('\\', '/', $content);
	}


	/**
	 * @param int $position
	 * @return bool
	 */
	private function isUseForNamespaceOrTrait($position)
	{
		$firstLetter = $this->file->getTokens()[$position + 2]['content'];
		if ($firstLetter === '(') { // use ($var)

67% of this comment could be valid code. Did you maybe forget this after debugging?

			return FALSE;
		}
		return TRUE;
	}

}