ScrambleUse::enterNode() - Code Metrics - naneau/php-obfuscator - Measure and Improve Code Quality continuously with Scrutinizer

ScrambleUse::enterNode() D
last analyzed 2016-12-19 15:58 UTC

↳ Parent: ScrambleUse

Complexity

Conditions	21
Paths	19

Size

Total Lines	84
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	84
rs	4.821
cc	21
eloc	38
nc	19
nop	1

How to fix Long Method Complexity

<?php
/**
 * ScrambleUse.php
 *
 * @category        Naneau
 * @package         Obfuscator
 * @subpackage      NodeVisitor
 */

namespace Naneau\Obfuscator\Node\Visitor;

use Naneau\Obfuscator\Node\Visitor\TrackingRenamerTrait;
use Naneau\Obfuscator\Node\Visitor\SkipTrait;

use Naneau\Obfuscator\Node\Visitor\Scrambler as ScramblerVisitor;

use PhpParser\Node;

use PhpParser\Node\Name;
use PhpParser\Node\Name\FullyQualified;

use PhpParser\Node\Param;

use PhpParser\Node\Stmt\Class_ as ClassStatement;
use PhpParser\Node\Stmt\Use_ as UseStatement;
use PhpParser\Node\Stmt\UseUse as UseUseStatement;
use PhpParser\Node\Stmt\StaticVar;

use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Expr\StaticPropertyFetch;
use PhpParser\Node\Expr\New_ as NewExpression;
use PhpParser\Node\Expr\Instanceof_ as InstanceOfExpression;

use PhpParser\Node\Expr\Variable;

/**
 * ScrambleUse
 *
 * @category        Naneau
 * @package         Obfuscator
 * @subpackage      NodeVisitor
 */
class ScrambleUse extends ScramblerVisitor
{
    use TrackingRenamerTrait;
    use SkipTrait;

    /**
     * Active class
     *
     * @var ClassStatement|bool
     **/
    private $classNode;

    /**
     * Before node traversal
     *
     * @param  Node[] $nodes
     * @return array
     **/
    public function beforeTraverse(array $nodes)
    {
        // Reset renamed list
        $this->resetRenamed();

        // Find the class node
        $this->classNode = $this->findClass($nodes);

        // Scan for use statements
        $this->scanUse($nodes);

        return $nodes;
    }

    /**
     * Check all variable nodes
     *
     * @param  Node $node
     * @return void
     **/
    public function enterNode(Node $node)
    {
        // Class statements
        if ($node instanceof ClassStatement) {
            // Classes that extend another class
            if ($node->extends !== null) {
                $extends = $node->extends->toString();
                if ($this->isRenamed($extends)) {
                    $node->extends = new Name($this->getNewName($extends));
                }
            }

            // Classes that implement an interface
            if ($node->implements !== null && count($node->implements) > 0) {

                $implements = array();

                foreach($node->implements as $implementsName) {

                    // Old name (as string)
                    $oldName = $implementsName->toString();

                    if ($this->isRenamed($oldName)) {
                        // If renamed, set new one
                        $implements[] = new Name($this->getNewName($oldName));
                    } else {
                        // If not renamed, pass old one
                        $implements[] = $implementsName;
                    }
                }

                $node->implements = $implements;
            }

            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;
            }
        }

        // Static call or constant lookup on class
        if (
            $node instanceof ClassConstFetch
            || $node instanceof StaticCall
            || $node instanceof StaticPropertyFetch
            || $node instanceof StaticVar
            || $node instanceof NewExpression
            || $node instanceof InstanceOfExpression
        ) {

            // We need to be in a class for this to work
            if (empty($this->classNode)) {
                return;
            }

            // We need a name
            if (!($node->class instanceof Name)) {
                return;
            }

            // Class name
            $name = $node->class->toString();

            if ($name === $this->classNode->name) {
                return;
            }

            // Has it been renamed?
            if ($this->isRenamed($name)) {
                $node->class = new Name($this->getNewName($name));
                return $node;
            }
        }
    }

    /**
     * Scramble at use statements
     *
     * @param  Node[] $nodes
     * @return void
     **/
    private function scanUse(array $nodes)
    {
        foreach ($nodes as $node) {
            // Scramble the private method definitions
            if ($node instanceof UseStatement) {
                foreach($node->uses as $useNode) {

                    // Record original name and scramble it
                    $originalName = $useNode->name->toString();

                    // Prefix all classes with underscores, but don't modify them further
                    $rename =
                        strpos($originalName, '_') === false
                        &&
                        count($useNode->name->parts) > 1;

                    if (!$rename) {
                        $useNode->name = new Name(
                            '\\' . $useNode->name
                        );

                        continue;
                    }

                    // Scramble into new use name
                    $newName = $this->scrambleString(
                        $originalName
                        . '-'
                        . $useNode->alias
                    );

                    // Record renaming of full class
                    $this->renamed($originalName, $newName);

                    // Record renaming of alias
                    $this->renamed($useNode->alias, $newName);

                    // Set the new alias
                    $useNode->alias = $newName;
                }
            }

            // Recurse over child nodes
            if (isset($node->stmts) && is_array($node->stmts)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $this->scanUse($node->stmts);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            }
        }
    }

    /**
     * Find (the first) class node in a set of nodes
     *
     * @param array $nodes
     * @return ClassStatement|bool returns falls if no class can be found
     **/
    private function findClass(array $nodes)
    {
        foreach($nodes as $node) {
            if ($node instanceof ClassStatement) {
                return $node;
            }

            if (isset($node->stmts) && is_array($node->stmts)) {
                $class = $this->findClass($node->stmts);

                if ($class instanceof ClassStatement) {
                    return $class;
                }
            }
        }

        return false;
    }
}


GitHub Access Token became invalid

ScrambleUse::enterNode() D
last analyzed 2016-12-19 15:58 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

1			<?php
2			/**
3			* ScrambleUse.php
4			*
5			* @category Naneau
6			* @package Obfuscator
7			* @subpackage NodeVisitor
8			*/
9
10			namespace Naneau\Obfuscator\Node\Visitor;
11
12			use Naneau\Obfuscator\Node\Visitor\TrackingRenamerTrait;
13			use Naneau\Obfuscator\Node\Visitor\SkipTrait;
14
15			use Naneau\Obfuscator\Node\Visitor\Scrambler as ScramblerVisitor;
16
17			use PhpParser\Node;
18
19			use PhpParser\Node\Name;
20			use PhpParser\Node\Name\FullyQualified;
21
22			use PhpParser\Node\Param;
23
24			use PhpParser\Node\Stmt\Class_ as ClassStatement;
25			use PhpParser\Node\Stmt\Use_ as UseStatement;
26			use PhpParser\Node\Stmt\UseUse as UseUseStatement;
27			use PhpParser\Node\Stmt\StaticVar;
28
29			use PhpParser\Node\Expr\ClassConstFetch;
30			use PhpParser\Node\Expr\StaticCall;
31			use PhpParser\Node\Expr\StaticPropertyFetch;
32			use PhpParser\Node\Expr\New_ as NewExpression;
33			use PhpParser\Node\Expr\Instanceof_ as InstanceOfExpression;
34
35			use PhpParser\Node\Expr\Variable;
36
37			/**
38			* ScrambleUse
39			*
40			* @category Naneau
41			* @package Obfuscator
42			* @subpackage NodeVisitor
43			*/
44			class ScrambleUse extends ScramblerVisitor
45			{
46			use TrackingRenamerTrait;
47			use SkipTrait;
48
49			/**
50			* Active class
51			*
52			* @var ClassStatement\|bool
53			**/
54			private $classNode;
55
56			/**
57			* Before node traversal
58			*
59			* @param Node[] $nodes
60			* @return array
61			**/
62			public function beforeTraverse(array $nodes)
63			{
64			// Reset renamed list
65			$this->resetRenamed();
66
67			// Find the class node
68			$this->classNode = $this->findClass($nodes);
69
70			// Scan for use statements
71			$this->scanUse($nodes);
72
73			return $nodes;
74			}
75
76			/**
77			* Check all variable nodes
78			*
79			* @param Node $node
80			* @return void
81			**/
82			public function enterNode(Node $node)
83			{
84			// Class statements
85			if ($node instanceof ClassStatement) {
86			// Classes that extend another class
87			if ($node->extends !== null) {
88			$extends = $node->extends->toString();
89			if ($this->isRenamed($extends)) {
90			$node->extends = new Name($this->getNewName($extends));
91			}
92			}
93
94			// Classes that implement an interface
95			if ($node->implements !== null && count($node->implements) > 0) {
96
97			$implements = array();
98
99			foreach($node->implements as $implementsName) {
100
101			// Old name (as string)
102			$oldName = $implementsName->toString();
103
104			if ($this->isRenamed($oldName)) {
105			// If renamed, set new one
106			$implements[] = new Name($this->getNewName($oldName));
107			} else {
108			// If not renamed, pass old one
109			$implements[] = $implementsName;
110			}
111			}
112
113			$node->implements = $implements;
114			}
115
116			return $node;
117			}
118
119			// Param rename
120			if ($node instanceof Param && $node->type instanceof Name) {
121
122			// Name
123			$name = $node->type->toString();
124
125			// Has it been renamed?
126			if ($this->isRenamed($name)) {
127			$node->type = $this->getNewName($name);
128			return $node;
129			}
130			}
131
132			// Static call or constant lookup on class
133			if (
134			$node instanceof ClassConstFetch
135			\|\| $node instanceof StaticCall
136			\|\| $node instanceof StaticPropertyFetch
137			\|\| $node instanceof StaticVar
138			\|\| $node instanceof NewExpression
139			\|\| $node instanceof InstanceOfExpression
140			) {
141
142			// We need to be in a class for this to work
143			if (empty($this->classNode)) {
144			return;
145			}
146
147			// We need a name
148			if (!($node->class instanceof Name)) {
149			return;
150			}
151
152			// Class name
153			$name = $node->class->toString();
154
155			if ($name === $this->classNode->name) {
156			return;
157			}
158
159			// Has it been renamed?
160			if ($this->isRenamed($name)) {
161			$node->class = new Name($this->getNewName($name));
162			return $node;
163			}
164			}
165			}
166
167			/**
168			* Scramble at use statements
169			*
170			* @param Node[] $nodes
171			* @return void
172			**/
173			private function scanUse(array $nodes)
174			{
175			foreach ($nodes as $node) {
176			// Scramble the private method definitions
177			if ($node instanceof UseStatement) {
178			foreach($node->uses as $useNode) {
179
180			// Record original name and scramble it
181			$originalName = $useNode->name->toString();
182
183			// Prefix all classes with underscores, but don't modify them further
184			$rename =
185			strpos($originalName, '_') === false
186			&&
187			count($useNode->name->parts) > 1;
188
189			if (!$rename) {
190			$useNode->name = new Name(
191			'\\' . $useNode->name
192			);
193
194			continue;
195			}
196
197			// Scramble into new use name
198			$newName = $this->scrambleString(
199			$originalName
200			. '-'
201			. $useNode->alias
202			);
203
204			// Record renaming of full class
205			$this->renamed($originalName, $newName);
206
207			// Record renaming of alias
208			$this->renamed($useNode->alias, $newName);
209
210			// Set the new alias
211			$useNode->alias = $newName;
212			}
213			}
214
215			// Recurse over child nodes
216			if (isset($node->stmts) && is_array($node->stmts)) {
			0 ignored issues – show Bug introduced 2015-12-10 00:13 UTC by Report Bug Copy Issue Report Accessing `stmts` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
217			$this->scanUse($node->stmts);
			0 ignored issues – show Bug introduced 2015-12-10 00:13 UTC by Report Bug Copy Issue Report Accessing `stmts` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
218			}
219			}
220			}
221
222			/**
223			* Find (the first) class node in a set of nodes
224			*
225			* @param array $nodes
226			* @return ClassStatement\|bool returns falls if no class can be found
227			**/
228			private function findClass(array $nodes)
229			{
230			foreach($nodes as $node) {
231			if ($node instanceof ClassStatement) {
232			return $node;
233			}
234
235			if (isset($node->stmts) && is_array($node->stmts)) {
236			$class = $this->findClass($node->stmts);
237
238			if ($class instanceof ClassStatement) {
239			return $class;
240			}
241			}
242			}
243
244			return false;
245			}
246			}
247

naneau / php-obfuscator

GitHub Access Token became invalid

ScrambleUse::enterNode() D last analyzed 2016-12-19 15:58 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

ScrambleUse::enterNode() D
last analyzed 2016-12-19 15:58 UTC