Current Rulesets
List of rulesets and rules contained in each ruleset.
Code Size Rules: The Code Size Ruleset contains a collection of rules that find code size related problems.
Design Rules: The Code Size Ruleset contains a collection of rules that find software design related problems.
Naming Rules: The Naming Ruleset contains a collection of rules about names - too long, too short, and so forth.
Unused Code Rules: The Unused Code Ruleset contains a collection of rules that find unused code.
Code Size Rules
CyclomaticComplexity: Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.
NPathComplexity: The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.
ExcessiveMethodLength: Violations of this rule usually indicate that the method is doing too much. Try to reduce the method size by creating helper methods and removing any copy/pasted code.
ExcessiveClassLength: Long Class files are indications that the class may be trying to do too much. Try to break it down, and reduce the size to something manageable.
ExcessiveParameterList: Long parameter lists can indicate that a new object should be created to wrap the numerous parameters. Basically, try to group the parameters together.
ExcessivePublicCount: A large number of public methods and attributes declared in a class can indicate the class may need to be broken up as increased effort will be required to thoroughly test it.
TooManyFields: Classes that have too many fields could be redesigned to have fewer fields, possibly through some nested object grouping of some of the information. For example, a class with city/state/zip fields could instead have one Address field.
TooManyMethods: A class with too many methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to have more fine grained objects.
ExcessiveClassComplexity: The WMC of a class is a good indicator of how much time and effort is required to modify and maintain this class. A large number of methods also means that this class has a greater potential impact on derived classes.
Design Rules
ExitExpression: An exit-expression within regular code is untestable and therefore it should be avoided. Consider to move the exit-expression into some kind of startup script where an error/exception code is returned to the calling environment.
EvalExpression: An eval-expression is untestable, a security risk and bad practice. Therefore it should be avoided. Consider to replace the eval-expression with regular code.
NumberOfChildren: A class with an excessive number of children is an indicator for an unbalanced class hierarchy. You should consider to refactor this class hierarchy.
DepthOfInheritance: A class with many parents is an indicator for an unbalanced and wrong class hierarchy. You should consider to refactor this class hierarchy.
Naming Rules
ShortVariable: Detects when a field, local, or parameter has a very short name.
LongVariable: Detects when a field, formal or local variable is declared with a long name.
ShortMethodName: Detects when very short method names are used.
ConstructorWithNameAsEnclosingClass: A constructor method should not have the same name as the enclosing class, consider to use the PHP 5 __construct method.
ConstantNamingConventions: Class/Interface constant nanmes should always be defined in uppercase.
BooleanGetMethodName: Looks for methods named 'getX()' with 'boolean' as the return type. The convention is to name these methods 'isX()' or 'hasX()'.
Unused Code Rules
UnusedPrivateField: Detects when a private field is declared and/or assigned a value, but not used.
UnusedLocalVariable: Detects when a local variable is declared and/or assigned, but not used.
UnusedPrivateMethod: Unused Private Method detects when a private method is declared but is unused.
UnusedFormalParameter: Avoid passing parameters to methods or constructors and then not using those parameters.
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.
