Feature/duplicated array keys

src/main/php/PHPMD/Rule/CleanCode/DuplicatedArrayKey.php

@@ -0,0 +1,132 @@
+<?php
+/**
+ * This file is part of PHP Mess Detector.
+ *
+ * Copyright (c) Manuel Pichler <mapi@phpmd.org>.
+ * All rights reserved.
+ *
+ * Licensed under BSD License
+ * For full copyright and license information, please see the LICENSE file.
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @author Manuel Pichler <mapi@phpmd.org>
+ * @copyright Manuel Pichler. All rights reserved.
+ * @license https://opensource.org/licenses/bsd-license.php BSD License
+ * @link http://phpmd.org/
+ */
+
+namespace PHPMD\Rule\CleanCode;
+
+use PDepend\Source\AST\AbstractASTNode;
+use PDepend\Source\AST\ASTArrayElement;
+use PDepend\Source\AST\ASTLiteral;
+use PDepend\Source\AST\ASTNode as PDependASTNode;
+use PHPMD\AbstractNode;
+use PHPMD\AbstractRule;
+use PHPMD\Node\ASTNode;
+use PHPMD\Rule\FunctionAware;
+use PHPMD\Rule\MethodAware;
+
+/**
+ * Duplicated Array Key Rule
+ *
+ * This rule detects duplicated array keys.
+ *
+ * @author Rafał Wrzeszcz <rafal.wrzeszcz@wrzasq.pl>
+ * @author Kamil Szymanaski <kamil.szymanski@gmail.com>
+ */
+class DuplicatedArrayKey extends AbstractRule implements MethodAware, FunctionAware
+{
+    /**
+     * Retrieves all arrays from single node and performs comparison logic on it
+     *
+     * @param AbstractNode $node
+     * @return void
+     */
+    public function apply(AbstractNode $node)
+    {
+        foreach ($node->findChildrenOfType('Array') as $arrayNode) {
+            /** @var ASTNode $arrayNode */
+            $this->checkForDuplicatedArrayKeys($arrayNode);
+        }
+    }
+
+    /**
+     * This method checks if a given function or method contains an array literal
+     * with duplicated entries for any key and emits a rule violation if so.
+     *
+     * @param ASTNode $node Array node.
+     * @return void
+     */
+    private function checkForDuplicatedArrayKeys(ASTNode $node)
+    {
+        $keys = array();
+        /** @var ASTArrayElement $arrayElement */
+        foreach ($node->getChildren() as $index => $arrayElement) {
+            $arrayElement = $this->normalizeKey($arrayElement, $index);
+            if (null === $arrayElement) {
+                // skip everything that can't be resolved easily
+                continue;
+            }
+
+            $key = $arrayElement->getImage();
+            if (isset($keys[$key])) {
+                $this->addViolation($node, array($key, $arrayElement->getStartLine()));
+                continue;
+            }
+            $keys[$key] = $arrayElement;
+        }
+    }
+
+    /**
+     * Changes key name to its string format.
+     *
+     * To compare keys, we have to cast them to string.
+     * Non-associative keys have to use index as its key,
+     * while boolean and nulls have to be casted respectively.
+     * As current logic doesn't evaluate expressions nor constants,
+     * statics, globals, etc. we simply skip them.
+     *
+     * @param AbstractASTNode $node Array key to evaluate.
+     * @param int $index Fallback in case of non-associative arrays
+     * @return AbstractASTNode Key name
+     */
+    private function normalizeKey(AbstractASTNode $node, $index)
+    {
+        // non-associative - key name equals to its index
+        if (count($node->getChildren()) === 0) {
+            $node->setImage((string) $index);
+            return $node;
+        }
+
+        $node = $node->getChild(0);
+        if (!($node instanceof ASTLiteral)) {
+            // skip expressions, method calls, globals and constants
+            return null;
+        }
+        $node->setImage($this->castStringFromLiteral($node));
+
+        return $node;
+    }
+
+    /**
+     * Cleans string literals and casts boolean and null values as PHP engine does
+     *
+     * @param PDependASTNode $key
+     * @return string
+     */
+    private function castStringFromLiteral(PDependASTNode $key)
+    {
+        $value = $key->getImage();
+        switch ($value) {
+            case 'false':
+                return '0';
+            case 'true':
+                return '1';
+            case 'null':
+                return '';
+            default:
+                return trim($value, '\'""');
+        }
+    }
+}

src/main/resources/rulesets/cleancode.xml

@@ -126,6 +126,33 @@ class Foo
     {
         Bar::baz();
     }
+}
+            ]]>
+        </example>
+    </rule>
+
+    <rule name="DuplicatedArrayKey"
+          message="Duplicated array key {0}, first declared at line {1}."
+          class="PHPMD\Rule\CleanCode\DuplicatedArrayKey"
+          externalInfoUrl="http://phpmd.org/rules/cleancode.html#duplicatedarraykey">
+        <description>
+            <![CDATA[
+Defining another value for the same key in an array literal overrides the previous key/value,
+which makes it effectively an unused code. If it's known from the beginning that the key
+will have different value, there is usually no point in defining first one.
+            ]]>
+        </description>
+        <priority>2</priority>
+        <example>
+            <![CDATA[
+function createArray() {
+    return [
+        'non-associative 0element', // not applied
+        0 => 'associative 0-element', // applied
+        false => 'associative 0-element', // applied
+        'foo' => 'bar', // not applied
+        "foo" => 'baz', // applied
+    ];
 }
             ]]>
         </example>

src/site/rst/rules/cleancode.rst

@@ -68,7 +68,7 @@ This rule has the following properties:
 =================================== =============== ===============================================
 
 IfStatementAssignment
-=============
+=====================
 
 Since: PHPMD 2.7.0
 
@@ -91,6 +91,27 @@ Example: ::
   }
 
 
+DuplicateArrayKey
+=================
+
+Since: PHPMD 2.7.0
+
+Defining another value for the same key in an array literal overrides the previous key/value, which makes it effectively an unused code. If it's known from the beginning that the key will have different value, there is usually no point in defining first one.
+
+
+Example: ::
+
+  function createArray() {
+      return [
+          'non-associative 0-element', // not applied
+          0 => 'associative 0-element', // applied
+          false => 'associative 0-element', // applied
+          'foo' => 'bar', // not applied
+          "foo" => 'baz', // applied
+      ];
+  }
+
+
 Remark
 ======
 

src/site/rst/rules/design.rst

@@ -211,4 +211,3 @@ Remark
   This document is based on a ruleset xml-file, that was taken from the original source of the `PMD`__ project. This means that most parts of the content on this page are the intellectual work of the PMD community and its contributors and not of the PHPMD project.
 
 __ http://pmd.sourceforge.net/
-

src/site/rst/rules/index.rst

@@ -24,10 +24,12 @@ Clean Code Rules
 - `BooleanArgumentFlag`__: A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
 - `ElseExpression`__: An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
 - `StaticAccess`__: Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.
+- `DuplicateArrayKey`__: Defining another value for the same key in an array literal overrides the previous key/value, which makes it effectively an unused code. If it's known from the beginning that the key will have different value, there is usually no point in defining first one.
 
 __ cleancode.html#booleanargumentflag
 __ cleancode.html#elseexpression
 __ cleancode.html#staticaccess
+__ cleancode.html#duplicatearraykey
 
 Code Size Rules
 ===============