tomzx / php-semver-checker

use PHPSemVerChecker\Registry\Registry;

use PHPSemVerChecker\Report\Report;

class ClassAnalyzer

{

	/**

	 * @var string

	 */

	protected $context = 'class';

	/**

	 * @param \PHPSemVerChecker\Registry\Registry $registryBefore

	 * @param \PHPSemVerChecker\Registry\Registry $registryAfter

	 * @return \PHPSemVerChecker\Report\Report

	 */

	public function analyze(Registry $registryBefore, Registry $registryAfter)

	{

		$report = new Report();

		$classesBefore = $registryBefore->data['class'];

		$classesAfter = $registryAfter->data['class'];

		$classesBeforeKeyed = [];

		$filesBeforeKeyed = [];

		foreach ($classesBefore as $key => $classBefore) {

			$classesBeforeKeyed[strtolower($classBefore->name)] = $classBefore;

			$filesBeforeKeyed[strtolower($classBefore->name)] = $registryBefore->mapping['class'][$key];

		}

		$classesAfterKeyed = [];

		$filesAfterKeyed = [];

		foreach ($classesAfter as $key => $classAfter) {

			$classesAfterKeyed[strtolower($classAfter->name)] = $classAfter;

			$filesAfterKeyed[strtolower($classAfter->name)] = $registryAfter->mapping['class'][$key];

		}

		$classNamesBefore = array_keys($classesBeforeKeyed);

		$classNamesAfter = array_keys($classesAfterKeyed);

		$added = array_diff($classNamesAfter, $classNamesBefore);

		$removed = array_diff($classNamesBefore, $classNamesAfter);

		$toVerify = array_intersect($classNamesBefore, $classNamesAfter);

		foreach ($removed as $key) {

			$fileBefore = $filesBeforeKeyed[$key];

			$classBefore = $classesBeforeKeyed[$key];

			$data = new ClassRemoved($fileBefore, $classBefore);

			$report->addClass($data);

		}

		foreach ($toVerify as $key) {

			$fileBefore = $filesBeforeKeyed[$key];

			/** @var \PhpParser\Node\Stmt\Class_ $classBefore */

			$classBefore = $classesBeforeKeyed[$key];

			$fileAfter = $filesAfterKeyed[$key];

			/** @var \PhpParser\Node\Stmt\Class_ $classBefore */

			$classAfter = $classesAfterKeyed[$key];

			// Leave non-strict comparison here

			if ($classBefore != $classAfter) {

				// Check for case change of class name.

				// If we entered this section then the normalized names (lowercase) were equal.

				if ($classBefore->name !== $classAfter->name) {

					$report->add(

						$this->context,

						new ClassCaseChanged(

							$fileBefore,

							$classBefore,

							$fileAfter,

							$classAfter

						)

					);

				}

				$analyzers = [

					new ClassMethodAnalyzer('class', $fileBefore, $fileAfter),

					new PropertyAnalyzer('class', $fileBefore, $fileAfter),

				];

				foreach ($analyzers as $analyzer) {

					$internalReport = $analyzer->analyze($classBefore, $classAfter);

					$report->merge($internalReport);

				}

			}

		}

		foreach ($added as $key) {

			$fileAfter = $filesAfterKeyed[$key];

			$classAfter = $classesAfterKeyed[$key];

			$data = new ClassAdded($fileAfter, $classAfter);

			$report->addClass($data);

		}

		return $report;

	}

}

use PHPSemVerChecker\Registry\Registry;

use PHPSemVerChecker\Report\Report;

class TraitAnalyzer

{

	/**

	 * @var string

	 */

	protected $context = 'trait';

	/**

	 * @param \PHPSemVerChecker\Registry\Registry $registryBefore

	 * @param \PHPSemVerChecker\Registry\Registry $registryAfter

	 * @return \PHPSemVerChecker\Report\Report

	 */

	public function analyze(Registry $registryBefore, Registry $registryAfter)

	{

		$report = new Report();

		$traitsBefore = $registryBefore->data['trait'];

		$traitsAfter = $registryAfter->data['trait'];

		$traitsBeforeKeyed = [];

		$filesBeforeKeyed = [];

		foreach ($traitsBefore as $key => $traitBefore) {

			$traitsBeforeKeyed[strtolower($traitBefore->name)] = $traitBefore;

			$filesBeforeKeyed[strtolower($traitBefore->name)] = $registryBefore->mapping['trait'][$key];

		}

		$traitsAfterKeyed = [];

		$filesAfterKeyed = [];

		foreach ($traitsAfter as $key => $traitAfter) {

			$traitsAfterKeyed[strtolower($traitAfter->name)] = $traitAfter;

			$filesAfterKeyed[strtolower($traitAfter->name)] = $registryAfter->mapping['trait'][$key];

		}

		$traitNamesBefore = array_keys($traitsBeforeKeyed);

		$traitNamesAfter = array_keys($traitsAfterKeyed);

		$added = array_diff($traitNamesAfter, $traitNamesBefore);

		$removed = array_diff($traitNamesBefore, $traitNamesAfter);

		$toVerify = array_intersect($traitNamesBefore, $traitNamesAfter);

		foreach ($removed as $key) {

			$fileBefore = $filesBeforeKeyed[$key];

			$traitBefore = $traitsBeforeKeyed[$key];

			$data = new TraitRemoved($fileBefore, $traitBefore);

			$report->addTrait($data);

		}

		foreach ($toVerify as $key) {

			$fileBefore = $filesBeforeKeyed[$key];

			$traitBefore = $traitsBeforeKeyed[$key];

			$fileAfter = $filesAfterKeyed[$key];

			$traitAfter = $traitsAfterKeyed[$key];

			// Leave non-strict comparison here

			if ($traitBefore != $traitAfter) {

				// Check for name case change.

				// If we entered this section then the normalized names (lowercase) were equal.

				if ($traitBefore->name !== $traitAfter->name) {

					$report->add(

						$this->context,

						new TraitCaseChanged(

							$fileBefore,

							$traitBefore,

							$fileAfter,

							$traitAfter

						)

					);

				}

				$analyzers = [

					new ClassMethodAnalyzer('trait', $fileBefore, $fileAfter),

					new PropertyAnalyzer('trait', $fileBefore, $fileAfter),

				];

				foreach ($analyzers as $analyzer) {

					$internalReport = $analyzer->analyze($traitBefore, $traitAfter);

					$report->merge($internalReport);

				}

			}

		}

		foreach ($added as $key) {

			$fileAfter = $filesAfterKeyed[$key];

			$traitAfter = $traitsAfter[$key];

			$data = new TraitAdded($fileAfter, $traitAfter);

			$report->addTrait($data);

		}

		return $report;

	}

}