ConstantVisibilityReduced::compare() - Code Metrics - Inspection of "Verify method, function, property, constant and in..." - Roave/BackwardCompatibilityCheck - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#38)

by Marco

created 2018-04-18 13:56 UTC

ConstantVisibilityReduced::compare() A

↳ Parent: ConstantVisibilityReduced

Complexity

Conditions	2
Paths	2

Size

Total Lines	19
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	12
nc	2
nop	2

<?php

declare(strict_types=1);

namespace Roave\ApiCompare\Comparator\BackwardsCompatibility\ClassConstantBased;

use Roave\ApiCompare\Change;
use Roave\ApiCompare\Changes;
use Roave\BetterReflection\Reflection\ReflectionClassConstant;

final class ConstantVisibilityReduced implements ConstantBased
{
    private const VISIBILITY_PRIVATE = 'private';

    private const VISIBILITY_PROTECTED = 'protected';

    private const VISIBILITY_PUBLIC = 'public';

    public function compare(ReflectionClassConstant $fromConstant, ReflectionClassConstant $toConstant) : Changes
    {
        $visibilityFrom = $this->propertyVisibility($fromConstant);
        $visibilityTo   = $this->propertyVisibility($toConstant);

        // Works because private, protected and public are sortable:
        if ($visibilityFrom <= $visibilityTo) {
            return Changes::new();
        }

        return Changes::fromArray([Change::changed(
            sprintf(
                'Constant %s::%s visibility reduced from %s to %s',
                $fromConstant->getDeclaringClass()->getName(),
                $fromConstant->getName(),
                $visibilityFrom,
                $visibilityTo
            ),
            true
        )]);
    }

    private function propertyVisibility(ReflectionClassConstant $property) : string
    {
        if ($property->isPublic()) {
            return self::VISIBILITY_PUBLIC;
        }

        if ($property->isProtected()) {
            return self::VISIBILITY_PROTECTED;
        }

        return self::VISIBILITY_PRIVATE;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Roave\ApiCompare\Comparator\BackwardsCompatibility\ClassConstantBased;
6
7			use Roave\ApiCompare\Change;
8			use Roave\ApiCompare\Changes;
9			use Roave\BetterReflection\Reflection\ReflectionClassConstant;
10
11			final class ConstantVisibilityReduced implements ConstantBased
12			{
13			private const VISIBILITY_PRIVATE = 'private';
14
15			private const VISIBILITY_PROTECTED = 'protected';
16
17			private const VISIBILITY_PUBLIC = 'public';
18
19			public function compare(ReflectionClassConstant $fromConstant, ReflectionClassConstant $toConstant) : Changes
20			{
21			$visibilityFrom = $this->propertyVisibility($fromConstant);
22			$visibilityTo = $this->propertyVisibility($toConstant);
23
24			// Works because private, protected and public are sortable:
25			if ($visibilityFrom <= $visibilityTo) {
26			return Changes::new();
27			}
28
29			return Changes::fromArray([Change::changed(
30			sprintf(
31			'Constant %s::%s visibility reduced from %s to %s',
32			$fromConstant->getDeclaringClass()->getName(),
33			$fromConstant->getName(),
34			$visibilityFrom,
35			$visibilityTo
36			),
37			true
38			)]);
39			}
40
41			private function propertyVisibility(ReflectionClassConstant $property) : string
42			{
43			if ($property->isPublic()) {
44			return self::VISIBILITY_PUBLIC;
45			}
46
47			if ($property->isProtected()) {
48			return self::VISIBILITY_PROTECTED;
49			}
50
51			return self::VISIBILITY_PRIVATE;
52			}
53			}
54

Roave / BackwardCompatibilityCheck

Pull Request — master (#38)

ConstantVisibilityReduced::compare() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like