Added functional tests, fixed private methods and variables scramblers

composer.json

@@ -22,7 +22,7 @@
     ],
 
     "require": {
-        "nikic/php-parser":              "~1@dev",
+        "nikic/php-parser":              "~3@dev",
         "symfony/console":               "~2.5",
         "symfony/dependency-injection":  "~2.5",
         "symfony/config":                "~2.5",

phpunit.xml

@@ -0,0 +1,2 @@
+<phpunit bootstrap="tests/phpunit.php" colors="true">
+</phpunit>

src/Naneau/Obfuscator/Node/Visitor/ScramblePrivateMethod.php

@@ -57,7 +57,9 @@ public function beforeTraverse(array $nodes)
             ->resetRenamed()
             ->skip($this->variableMethodCallsUsed($nodes));
 
-        $this->scanMethodDefinitions($nodes);
+        if (!$this->shouldSkip()) {
+            $this->scanMethodDefinitions($nodes);
+        }
 
         return $nodes;
     }
@@ -75,8 +77,7 @@ public function enterNode(Node $node)
         }
 
         // Scramble calls
-        if ($node instanceof MethodCall || $node instanceof StaticCall) {
-
+        if (($node instanceof MethodCall && $node->var->name === 'this') || ($node instanceof StaticCall && $node->class instanceof Node\Name && $node->class->toString() === 'self')) {
             // Node wasn't renamed
             if (!$this->isRenamed($node->name)) {
                 return;
@@ -96,7 +97,7 @@ public function enterNode(Node $node)
     private function variableMethodCallsUsed(array $nodes)
     {
         foreach ($nodes as $node) {
-            if ($node instanceof MethodCall && $node->name instanceof Variable) {
+            if ($node instanceof MethodCall && $node->name instanceof Variable && $node->var->name === "this") {
                 // A method call uses a Variable as its name
                 return true;
             }

src/Naneau/Obfuscator/Node/Visitor/ScramblePrivateProperty.php

@@ -78,7 +78,18 @@ public function enterNode(Node $node)
     {
         if ($node instanceof PropertyFetch) {
 
-            if (!is_string($node->name)) {
+            if (!is_string($node->name) || $node->var->name !== "this") {
+                return;
+            }
+
+            if ($this->isRenamed($node->name)) {
+                $node->name = $this->getNewName($node->name);
+                return $node;
+            }
+        }
+
+        if ($node instanceof Node\Expr\StaticPropertyFetch) {
+            if ((string)$node->class !== "self") {
                 return;
             }
 

src/Naneau/Obfuscator/Node/Visitor/ScrambleUse.php

@@ -88,13 +88,16 @@ public function enterNode(Node $node)
                 $extends = $node->extends->toString();
                 if ($this->isRenamed($extends)) {
                     $node->extends = new Name($this->getNewName($extends));
+                } elseif ($this->isRenamed($node->extends->getFirst())) {
+                    reset($node->extends->parts);
+                    $node->extends->parts[key($node->extends->parts)] = $this->getNewName($node->extends->getFirst());
                 }
             }
 
             // Classes that implement an interface
             if ($node->implements !== null && count($node->implements) > 0) {
 
-                $implements = array();
+                $implements = [];
 
                 foreach($node->implements as $implementsName) {
 
@@ -104,6 +107,10 @@ public function enterNode(Node $node)
                     if ($this->isRenamed($oldName)) {
                         // If renamed, set new one
                         $implements[] = new Name($this->getNewName($oldName));
+                    } elseif ($this->isRenamed($implementsName->getFirst())) {
+                        reset($implementsName->parts);
+                        $implementsName->parts[key($implementsName->parts)] = $this->getNewName($implementsName->getFirst());
+                        $implements[] = $implementsName;
                     } else {
                         // If not renamed, pass old one
                         $implements[] = $implementsName;
@@ -116,16 +123,67 @@ public function enterNode(Node $node)
             return $node;
         }
 
+        if ($node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Expr\Closure) {
+
+            if ($node->returnType instanceof Name) {
+                // Name
+                $name = $node->returnType->toString();
+
+                // Has it been renamed?
+                if ($this->isRenamed($name)) {
+                    $node->returnType = $this->getNewName($name);
+                    return $node;
+                } elseif ($this->isRenamed($node->returnType->getFirst())) {
+                    reset($node->returnType->parts);
+                    $node->returnType->parts[key($node->returnType->parts)] = $this->getNewName($node->returnType->getFirst());
+                    return $node;
+                }
+            }
+
+            if ($node->returnType instanceof Node\NullableType && $node->returnType->type instanceof Name) {
+                // Name
+                $name = $node->returnType->type->toString();
+
+                // Has it been renamed?
+                if ($this->isRenamed($name)) {
+                    $node->returnType->type = $this->getNewName($name);
+                    return $node;
+                } elseif ($this->isRenamed($node->returnType->type->getFirst())) {
+                    reset($node->returnType->type->parts);
+                    $node->returnType->type->parts[key($node->returnType->type->parts)] = $this->getNewName($node->returnType->type->getFirst());
+                    return $node;
+                }
+            }
+        }
+
+        if ($node instanceof Param && $node->type instanceof Node\NullableType && $node->type->type instanceof Name) {
+            // Name
+            $name = $node->type->type->toString();
+
+            // Has it been renamed?
+            if ($this->isRenamed($name)) {
+                $node->type->type = $this->getNewName($name);
+                return $node;
+            } elseif ($this->isRenamed($node->type->type->getFirst())) {
+                reset($node->type->type->parts);
+                $node->type->type->parts[key($node->type->type->parts)] = $this->getNewName($node->type->type->getFirst());
+                return $node;
+            }
+        }
+
         // Param rename
         if ($node instanceof Param && $node->type instanceof Name) {
-
             // Name
             $name = $node->type->toString();
 
             // Has it been renamed?
             if ($this->isRenamed($name)) {
                 $node->type = $this->getNewName($name);
                 return $node;
+            } elseif ($this->isRenamed($node->type->getFirst())) {
+                reset($node->type->parts);
+                $node->type->parts[key($node->type->parts)] = $this->getNewName($node->type->getFirst());
+                return $node;
             }
         }
 
@@ -138,7 +196,6 @@ public function enterNode(Node $node)
             || $node instanceof NewExpression
             || $node instanceof InstanceOfExpression
         ) {
-
             // We need to be in a class for this to work
             if (empty($this->classNode)) {
                 return;
@@ -160,6 +217,12 @@ public function enterNode(Node $node)
             if ($this->isRenamed($name)) {
                 $node->class = new Name($this->getNewName($name));
                 return $node;
+            } else {
+                if ($this->isRenamed($node->class->getFirst())) {
+                    reset($node->class->parts);
+                    $node->class->parts[key($node->class->parts)] = $this->getNewName($node->class->getFirst());
+                    return $node;
+                }
             }
         }
     }

src/Naneau/Obfuscator/Resources/services.yml

@@ -70,7 +70,7 @@ services:
 
     # Parser
     obfuscator.parser:
-        class: PhpParser\Parser
+        class: PhpParser\Parser\Php7
         arguments:
             - @obfuscator.lexer
 

tests/Base.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Tests;
+
+class Base extends \PHPUnit_Framework_TestCase {
+
+}

tests/ObfuscateTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Tests;
+
+class ObfuscateTest extends Base {
+
+    const AFTER_PATH    = "/after";
+    const BEFORE_PATH   = "/before";
+    const EXPECTED_PATH = "/expected";
+
+    protected function tearDown() {
+        $files = glob(__DIR__ . self::AFTER_PATH . "/*");
+        foreach ($files as $file) {
+            unlink($file);
+        }
+        rmdir(__DIR__ . self::AFTER_PATH);
+    }
+
+    public function testObfuscate() {
+        shell_exec("./bin/obfuscate obfuscate " . __DIR__ . self::BEFORE_PATH . " " . __DIR__ . self::AFTER_PATH . " --config=" . __DIR__ . "/config.yml");
+        $expectedFileNames = scandir(__DIR__ . self::EXPECTED_PATH);
+        foreach ($expectedFileNames as $expectedFileName) {
+            if ($expectedFileName === '.' || $expectedFileName === '..') {
+                continue;
+            }
+            if (!file_exists(__DIR__ . self::AFTER_PATH . "/" . $expectedFileName)) {
+                $this->fail("{$expectedFileName} not found");
+            }
+            $this->assertEquals(file_get_contents(__DIR__ . self::EXPECTED_PATH . "/" . $expectedFileName), file_get_contents(__DIR__ . self::AFTER_PATH . "/" . $expectedFileName));
+        }
+    }
+}

tests/before/Functions.php

@@ -0,0 +1,21 @@
+<?php
+
+
+function functionA($argumentVar) {
+    $localVarA = 3;
+    return $argumentVar + $localVarA;
+}
+
+function functionB() {
+    $localVarB = 5;
+    return functionB($localVarB);
+}
+
+function functionC(?int $a): ?string {
+    return $a === null ? null : "Output: " . $a;
+}
+
+$localVarMainA = "local value";
+$localVarMainB = functionB();
+$localVarMainA = functionA($localVarMainA);
+functionC();

tests/before/MultipleClasses.php

@@ -0,0 +1,60 @@
+<?php
+
+class FirstClass {
+
+    protected $_protectedProperty;
+    public $publicProperty;
+
+    protected function _protectedMethod() {
+        echo "This is protected method of first class";
+    }
+
+    public function publicMethod() {
+        echo "This is public method of first class";
+    }
+}
+
+class SecondClass extends FirstClass {
+
+    private $_privateProperty;
+
+    protected function _protectedMethod() {
+        parent::_protectedMethod();
+        echo "This is protected method of second class";
+        $this->_privateProperty = parent::$_protectedProperty;
+    }
+
+    public function publicMethod() {
+        parent::publicMethod();
+        echo "This is public method of second class";
+        $this->_privateProperty = parent::$publicProperty;
+    }
+
+    static public function anotherPublicMethod() {
+    }
+}
+
+class ThirdClass {
+
+    private $publicProperty;
+
+    static private function anotherPublicMethod() {
+
+    }
+
+    public function __construct(SecondClass $secondObject) {
+        $secondObject->publicMethod();
+        $secondObject::anotherPublicMethod();
+        $secondObject->publicProperty = 'test';
+    }
+
+    private function publicMethod() {
+        echo 'test';
+    }
+
+    protected function someFunc() {
+        $this->publicProperty = 'test';
+        $this->publicMethod();
+        self::anotherPublicMethod();
+    }
+}

tests/before/Namespaces.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace namespaceA;
+
+class classA {
+
+}
+
+namespace namespaceC\namespaceD;
+
+class classD {
+
+}
+
+interface interfaceA {
+
+}
+
+namespace namespaceB;
+
+use namespaceA\classA as classC;
+use namespaceC\namespaceD as namespaceDAlias;
+
+class classB {
+
+    private $_objectA;
+
+    private $_objectB;
+
+    public function __construct() {
+        $this->_objectA = new classC();
+        $this->_objectB = new namespaceDAlias\classD();
+    }
+}
+
+class classE extends namespaceDAlias\classD implements namespaceDAlias\interfaceA {
+
+    public function method(?namespaceDAlias\classD $objectD) : ?namespaceDAlias\classD {
+        $func = function () : ?namespaceDAlias\classD {
+
+        };
+    }
+}