Merge branch 'fix-namespaced-compact' of https://github.com/radmen/phpmd

 into radmen-fix-namespaced-compact

src/main/php/PHPMD/Rule/AbstractLocalVariable.php

@@ -144,7 +144,7 @@ protected function stripWrappedIndexExpression(ASTNode $node)
         if (false === $this->isWrappedByIndexExpression($node)) {
             return $node;
         }
-        
+
         $parent = $node->getParent();
         if ($parent->getChild(0)->getNode() === $node->getNode()) {
             return $this->stripWrappedIndexExpression($parent);
@@ -177,4 +177,19 @@ protected function isFunctionNameEqual(AbstractNode $node, $name)
     {
         return (0 === strcasecmp(trim($node->getImage(), '\\'), $name));
     }
+
+    /**
+     * AST puts namespace prefix to global functions called from a namespace.
+     * This method checks if the last part of function fully qualified name is equal to $name
+     *
+     * @param \PHPMD\AbstractNode $node
+     * @param string $name
+     * @return boolean
+     */
+    protected function isFunctionNameEndingWith(AbstractNode $node, $name)
+    {
+        $parts = explode('\\', trim($node->getImage(), '\\'));
+
+        return (0 === strcasecmp(array_pop($parts), $name));
+    }
 }

src/main/php/PHPMD/Rule/UnusedFormalParameter.php

@@ -109,7 +109,7 @@ private function isAbstractMethod(AbstractNode $node)
         }
         return false;
     }
-    
+
     /**
      * Returns <b>true</b> when the given node is method with signature declared as inherited using
      * {@inheritdoc} annotation.
@@ -185,7 +185,8 @@ private function removeUsedParameters(AbstractNode $node)
             if ($this->isFunctionNameEqual($functionCall, 'func_get_args')) {
                 $this->nodes = array();
             }
-            if ($this->isFunctionNameEqual($functionCall, 'compact')) {
+
+            if ($this->isFunctionNameEndingWith($functionCall, 'compact')) {
                 foreach ($functionCall->findChildrenOfType('Literal') as $literal) {
                     unset($this->nodes['$' . trim($literal->getImage(), '"\'')]);
                 }

src/main/php/PHPMD/Rule/UnusedLocalVariable.php

@@ -128,7 +128,7 @@ private function collectVariables(AbstractCallableNode $node)
             $this->collectVariable($variable);
         }
         foreach ($node->findChildrenOfType('FunctionPostfix') as $func) {
-            if ($this->isFunctionNameEqual($func, 'compact')) {
+            if ($this->isFunctionNameEndingWith($func, 'compact')) {
                 foreach ($func->findChildrenOfType('Literal') as $literal) {
                     $this->collectLiteral($literal);
                 }

src/test/php/PHPMD/Rule/UnusedFormalParameterTest.php

@@ -420,4 +420,40 @@ public function test_compact_function_rule_works_case_insensitive()
         $rule->setReport($this->getReportMock(0));
         $rule->apply($this->getMethod());
     }
+
+    /**
+     * @test
+     * @return void
+     * @since 2.0.1
+     */
+    public function test_namespaced_compact_function_rule_does_not_apply()
+    {
+        $rule = new UnusedFormalParameter();
+        $rule->setReport($this->getReportMock(0));
+        $rule->apply($this->getMethod());
+    }
+
+    /**
+     * @test
+     * @return void
+     * @since 2.0.1
+     */
+    public function test_namespaced_compact_function_rule_only_applies_to_used_parameters()
+    {
+        $rule = new UnusedFormalParameter();
+        $rule->setReport($this->getReportMock(2));
+        $rule->apply($this->getMethod());
+    }
+
+    /**
+     * @test
+     * @return void
+     * @since 2.0.1
+     */
+    public function test_namespaced_compact_function_rule_works_case_insensitive()
+    {
+        $rule = new UnusedFormalParameter();
+        $rule->setReport($this->getReportMock(0));
+        $rule->apply($this->getMethod());
+    }
 }

src/test/php/PHPMD/Rule/UnusedLocalVariableTest.php

@@ -512,4 +512,39 @@ public function test_compact_function_rule_works_case_insensitive()
         $rule->setReport($this->getReportMock(0));
         $rule->apply($this->getMethod());
     }
+
+    /**
+     * testRuleDoesNotApplyToNamespacedCompactFunction
+     *
+     * <code>
+     * namespace Baz;
+     *
+     * class Foo {
+     *     public function bar() {
+     *         $key = 'ok';
+     *         return compact('key');
+     *     }
+     * }
+     * </code>
+     *
+     * @return void
+     */
+    public function testRuleDoesNotApplyToNamespacedCompactFunction()
+    {
+        $rule = new UnusedLocalVariable();
+        $rule->setReport($this->getReportMock(0));
+        $rule->apply($this->getMethod());
+    }
+
+    /**
+     * @test
+     * @return void
+     * @since 2.0.1
+     */
+    public function test_namespaced_compact_function_rule_works_case_insensitive()
+    {
+        $rule = new UnusedLocalVariable();
+        $rule->setReport($this->getReportMock(0));
+        $rule->apply($this->getMethod());
+    }
 }

src/test/resources/files/Rule/UnusedFormalParameter/test_namespaced_compact_function_rule_does_not_apply.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace PHPMDTest;
+
+class test_namespaced_compact_function_rule_does_not_apply
+{
+    public function test_namespaced_compact_function_rule_does_not_apply($foo, $bar)
+    {
+        return compact('foo', 'bar');
+    }
+}

src/test/resources/files/Rule/UnusedFormalParameter/test_namespaced_compact_function_rule_only_applies_to_used_parameters.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace PHPMDTest;
+
+class test_namespaced_compact_function_rule_only_applies_to_used_parameters
+{
+    public function test_namespaced_compact_function_rule_only_applies_to_used_parameters($foo, $bar, $baz)
+    {
+        return compact('bar');
+    }
+}

src/test/resources/files/Rule/UnusedFormalParameter/test_namespaced_compact_function_rule_works_case_insensitive.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace PHPMDTest;
+
+class test_namespaced_compact_function_rule_works_case_insensitive
+{
+    public function test_namespaced_compact_function_rule_works_case_insensitive($foo, $bar)
+    {
+        return Compact('foo', 'bar');
+    }
+}

src/test/resources/files/Rule/UnusedLocalVariable/testRuleDoesNotApplyToNamespacedCompactFunction.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace PHPMDTest;
+
+class testRuleDoesNotApplyToNamespacedCompactFunction
+{
+    public function testRuleDoesNotApplyToNamespacedCompactFunction()
+    {
+        $key = 'ok';
+        return compact('key');
+    }
+}

src/test/resources/files/Rule/UnusedLocalVariable/test_namespaced_compact_function_rule_works_case_insensitive.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace PHPMDTest;
+
+class test_namespaced_compact_function_rule_works_case_insensitive
+{
+    public function test_namespaced_compact_function_rule_works_case_insensitive()
+    {
+        $foo = 1; $bar = 2; $baz = 0;
+
+        return Compact('foo', 'bar', 'baz');
+    }
+}