[Rector] Add ChangeMethodVisibilityRector

src/Exception/InvalidNodeTypeException.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Exception;
+
+use Exception;
+
+final class InvalidNodeTypeException extends Exception
+{
+}

src/NodeModifier/VisibilityModifier.php

@@ -0,0 +1,48 @@
+<?php declare(strict_types=1);
+
+namespace Rector\NodeModifier;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Property;
+use Rector\Exception\InvalidNodeTypeException;
+
+final class VisibilityModifier
+{
+    /**
+     * This way "abstract", "static", "final" are kept
+     *
+     * @param ClassMethod|Property $node
+     */
+    public function removeOriginalVisibilityFromFlags($node): void
+    {
+        $this->ensureIsClassMethodOrProperty($node, __METHOD__);
+
+        if ($node->isPublic()) {
+            $node->flags -= Class_::MODIFIER_PUBLIC;
+        }
+
+        if ($node->isProtected()) {
+            $node->flags -= Class_::MODIFIER_PROTECTED;
+        }
+
+        if ($node->isPrivate()) {
+            $node->flags -= Class_::MODIFIER_PRIVATE;
+        }
+    }
+
+    private function ensureIsClassMethodOrProperty(Node $node, string $location): void
+    {
+        if ($node instanceof ClassMethod || $node instanceof Property) {
+            return;
+        }
+
+        throw new InvalidNodeTypeException(sprintf(
+            '"%s" only accepts "%s" types. "%s" given.',
+            $location,
+            implode('", "', [ClassMethod::class, Property::class]),
+            get_class($node)
+        ));
+    }
+}

src/Rector/Visibility/ChangeMethodVisibilityRector.php

@@ -0,0 +1,122 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Rector\Visibility;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\ClassMethod;
+use Rector\Node\Attribute;
+use Rector\NodeModifier\VisibilityModifier;
+use Rector\Rector\AbstractRector;
+use Rector\RectorDefinition\CodeSample;
+use Rector\RectorDefinition\RectorDefinition;
+
+final class ChangeMethodVisibilityRector extends AbstractRector
+{
+    /**
+     * @var string[] { class => [ method name => visibility ] }
+     */
+    private $methodToVisibilityByClass = [];
+
+    /**
+     * @var VisibilityModifier
+     */
+    private $visibilityModifier;
+
+    /**
+     * @param string[] $methodToVisibilityByClass
+     */
+    public function __construct(array $methodToVisibilityByClass, VisibilityModifier $visibilityModifier)
+    {
+        $this->methodToVisibilityByClass = $methodToVisibilityByClass;
+        $this->visibilityModifier = $visibilityModifier;
+    }
+
+    public function getDefinition(): RectorDefinition
+    {
+        return new RectorDefinition(
+            'Change visibility of method from parent class.',
+            [new CodeSample(
+<<<'CODE_SAMPLE'
+class FrameworkClass
+{
+    protected someMethod()
+    {
+    }
+}
+
+class MyClass extends FrameworkClass
+{
+    public someMethod()
+    {
+    }
+}
+CODE_SAMPLE
+                ,
+<<<'CODE_SAMPLE'
+class FrameworkClass
+{
+    protected someMethod()
+    {
+    }
+}
+
+class MyClass extends FrameworkClass
+{
+    protected someMethod()
+    {
+    }
+}
+CODE_SAMPLE
+            )]
+        );
+    }
+
+    public function isCandidate(Node $node): bool
+    {
+        if (! $node instanceof ClassMethod) {
+            return false;
+        }
+
+        // doesn't have a parent class
+        if (! $node->hasAttribute(Attribute::PARENT_CLASS_NAME)) {
+            return false;
+        }
+
+        $nodeParentClassName = $node->getAttribute(Attribute::PARENT_CLASS_NAME);
+        if (! isset($this->methodToVisibilityByClass[$nodeParentClassName])) {
+            return false;
+        }
+
+        $methodName = $node->name->toString();
+
+        return isset($this->methodToVisibilityByClass[$nodeParentClassName][$methodName]);
+    }
+
+    /**
+     * @param ClassMethod $classMethodNode
+     */
+    public function refactor(Node $classMethodNode): ?Node
+    {
+        $nodeParentClassName = $classMethodNode->getAttribute(Attribute::PARENT_CLASS_NAME);
+        $methodName = $classMethodNode->name->toString();
+
+        $newVisibility = $this->methodToVisibilityByClass[$nodeParentClassName][$methodName];
+
+        $this->visibilityModifier->removeOriginalVisibilityFromFlags($classMethodNode);
+
+        if ($newVisibility === 'public') {
+            $classMethodNode->flags |= Class_::MODIFIER_PUBLIC;
+        }
+
+        if ($newVisibility === 'protected') {
+            $classMethodNode->flags |= Class_::MODIFIER_PROTECTED;
+        }
+
+        if ($newVisibility === 'private') {
+            $classMethodNode->flags |= Class_::MODIFIER_PRIVATE;
+        }
+
+        return $classMethodNode;
+    }
+}

src/Rector/Visibility/ChangePropertyVisibilityRector.php

@@ -6,6 +6,7 @@ use PhpParser\Node;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\Property;
 use Rector\Node\Attribute;
+use Rector\NodeModifier\VisibilityModifier;
 use Rector\Rector\AbstractRector;
 use Rector\RectorDefinition\CodeSample;
 use Rector\RectorDefinition\RectorDefinition;
@@ -17,12 +18,18 @@ final class ChangePropertyVisibilityRector extends AbstractRector
      */
     private $propertyToVisibilityByClass = [];
 
+    /**
+     * @var VisibilityModifier
+     */
+    private $visibilityModifier;
+
     /**
      * @param string[] $propertyToVisibilityByClass
      */
-    public function __construct(array $propertyToVisibilityByClass)
+    public function __construct(array $propertyToVisibilityByClass, VisibilityModifier $visibilityModifier)
     {
         $this->propertyToVisibilityByClass = $propertyToVisibilityByClass;
+        $this->visibilityModifier = $visibilityModifier;
     }
 
     public function getDefinition(): RectorDefinition
@@ -90,7 +97,7 @@ CODE_SAMPLE
 
         $newVisibility = $this->propertyToVisibilityByClass[$nodeParentClassName][$propertyName];
 
-        $this->removeOriginalVisibilityFromFlags($propertyNode);
+        $this->visibilityModifier->removeOriginalVisibilityFromFlags($propertyNode);
 
         if ($newVisibility === 'public') {
             $propertyNode->flags |= Class_::MODIFIER_PUBLIC;
@@ -106,22 +113,4 @@ CODE_SAMPLE
 
         return $propertyNode;
     }
-
-    /**
-     * This way "abstract", "static", "final" are kept
-     */
-    private function removeOriginalVisibilityFromFlags(Property $propertyNode): void
-    {
-        if ($propertyNode->isPublic()) {
-            $propertyNode->flags -= Class_::MODIFIER_PUBLIC;
-        }
-
-        if ($propertyNode->isProtected()) {
-            $propertyNode->flags -= Class_::MODIFIER_PROTECTED;
-        }
-
-        if ($propertyNode->isPrivate()) {
-            $propertyNode->flags -= Class_::MODIFIER_PRIVATE;
-        }
-    }
 }

tests/Rector/Visibility/ChangeMethodVisibilityRector/ChangePropertyVisibilityRectorTest.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Tests\Rector\Visibility\ChangeMethodVisibilityRector;
+
+use Iterator;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+/**
+ * @covers \Rector\Rector\Visibility\ChangeMethodVisibilityRector
+ */
+final class ChangePropertyVisibilityRectorTest extends AbstractRectorTestCase
+{
+    /**
+     * @dataProvider provideWrongToFixedFiles()
+     */
+    public function test(string $wrong, string $fixed): void
+    {
+        $this->doTestFileMatchesExpectedContent($wrong, $fixed);
+    }
+
+    public function provideWrongToFixedFiles(): Iterator
+    {
+        yield [__DIR__ . '/Wrong/wrong.php.inc', __DIR__ . '/Correct/correct.php.inc'];
+        yield [__DIR__ . '/Wrong/wrong2.php.inc', __DIR__ . '/Correct/correct2.php.inc'];
+    }
+
+    protected function provideConfig(): string
+    {
+        return __DIR__ . '/config.yml';
+    }
+}

tests/Rector/Visibility/ChangeMethodVisibilityRector/Correct/correct.php.inc

@@ -0,0 +1,16 @@
+<?php declare (strict_types=1);
+
+use Rector\Tests\Rector\Visibility\ChangeMethodVisibilityRector\Source\ParentObject;
+
+class ClassThatInherits extends ParentObject
+{
+    public function toBePublicMethod() {
+
+    }
+    protected function toBeProtectedMethod() {
+
+    }
+    private function toBePrivateMethod() {
+
+    }
+}

tests/Rector/Visibility/ChangeMethodVisibilityRector/Correct/correct2.php.inc

@@ -0,0 +1,10 @@
+<?php declare (strict_types=1);
+
+use Rector\Tests\Rector\Visibility\ChangeMethodVisibilityRector\Source\ParentObject;
+
+class ClassThatInherits extends ParentObject
+{
+    public function toBePublicStaticMethod() {
+
+    }
+}

tests/Rector/Visibility/ChangeMethodVisibilityRector/Source/ParentObject.php

@@ -0,0 +1,21 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Tests\Rector\Visibility\ChangeMethodVisibilityRector\Source;
+
+class ParentObject
+{
+    public function toBePublicMethod() {
+
+    }
+
+    public function toBePublicStaticMethod() {
+
+    }
+
+    protected function toBeProtectedMethod() {
+
+    }
+    private function toBePrivateMethod() {
+
+    }
+}

tests/Rector/Visibility/ChangeMethodVisibilityRector/Wrong/wrong.php.inc

@@ -0,0 +1,16 @@
+<?php declare (strict_types=1);
+
+use Rector\Tests\Rector\Visibility\ChangeMethodVisibilityRector\Source\ParentObject;
+
+class ClassThatInherits extends ParentObject
+{
+    private function toBePublicMethod() {
+
+    }
+    public function toBeProtectedMethod() {
+
+    }
+    protected function toBePrivateMethod() {
+
+    }
+}

tests/Rector/Visibility/ChangeMethodVisibilityRector/Wrong/wrong2.php.inc

@@ -0,0 +1,10 @@
+<?php declare (strict_types=1);
+
+use Rector\Tests\Rector\Visibility\ChangeMethodVisibilityRector\Source\ParentObject;
+
+class ClassThatInherits extends ParentObject
+{
+    private function toBePublicStaticMethod() {
+
+    }
+}

tests/Rector/Visibility/ChangeMethodVisibilityRector/config.yml

@@ -0,0 +1,8 @@
+services:
+    Rector\Rector\Visibility\ChangeMethodVisibilityRector:
+        $methodToVisibilityByClass:
+            'Rector\Tests\Rector\Visibility\ChangeMethodVisibilityRector\Source\ParentObject':
+                'toBePublicMethod': 'public'
+                'toBeProtectedMethod': 'protected'
+                'toBePrivateMethod': 'private'
+                'toBePublicStaticMethod': 'public'