gpt: Automated pattern documentation updates

Author: nicklem

docs/description/description.json

@@ -1,26 +1,28 @@
 [
   {
     "patternId": "rulesets-cleancode.xml-ElseExpression",
-    "title": "Avoid else expressions",
-    "description": "Use return statements instead of else expression",
-    "timeToFix": 15
+    "title": "Refactor Else Statements with Early Returns",
+    "description": "Promotes early returns over else statements.",
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:35:52.861Z"
   },
   {
     "patternId": "rulesets-cleancode.xml-StaticAccess",
-    "title": "Avoid static access",
-    "description": "Static access leads to hard to test code",
+    "title": "Avoid Static Access to Reduce Dependencies",
+    "description": "Static access heightens dependencies and complicates testing.",
     "timeToFix": 15,
     "parameters": [
       {
         "name": "exceptions",
         "description": "Comma-separated class name list of exceptions"
       }
-    ]
+    ],
+    "patPatBotReviewed": "2024-05-23T14:35:59.524Z"
   },
   {
     "patternId": "rulesets-codesize.xml-CyclomaticComplexity",
-    "title": "Cyclomatic complexity",
-    "description": "This pattern reports methods with high cyclomatic complexity",
+    "title": "Measuring Cyclomatic Complexity in Methods",
+    "description": "Evaluates decision points to determine code complexity.",
     "parameters": [
       {
         "name": "reportLevel",
@@ -35,91 +37,99 @@
         "description": "Indicate if method average violation should be included"
       }
     ],
-    "timeToFix": 30
+    "timeToFix": 30,
+    "patPatBotReviewed": "2024-05-23T14:36:04.929Z"
   },
   {
     "patternId": "rulesets-codesize.xml-NPathComplexity",
-    "title": "NPath complexity",
-    "description": "This pattern reports methods with a large number of possible paths",
+    "title": "NPath Complexity Detection",
+    "description": "Measures possible execution paths in methods.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold"
       }
     ],
-    "timeToFix": 30
+    "timeToFix": 30,
+    "patPatBotReviewed": "2024-05-23T14:36:13.622Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveMethodLength",
-    "title": "Excessive method length",
-    "description": "This pattern reports excessively long methods.",
+    "title": "Method Length Warning",
+    "description": "Long methods may indicate excessive functionality.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold for the number of lines in a method"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:36:18.001Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveClassLength",
-    "title": "Excessive class length",
-    "description": "This pattern reports excessively long classes.",
+    "title": "Reducing Excessive Class Length",
+    "description": "Class files are too lengthy.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold for the number of lines in a class"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:36:22.011Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveParameterList",
-    "title": "Excessive parameters",
-    "description": "This pattern reports methods with a high number of parameters.",
+    "title": "Avoid Long Parameter Lists",
+    "description": "Simplify functions by reducing long parameter lists.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold for the number of arguments in a method"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:36:26.426Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessivePublicCount",
-    "title": "Excessive public attributes",
-    "description": "This pattern reports classes with a high number of public methods and attributes.",
+    "title": "Too Many Public Members",
+    "description": "A flag for classes with excessive public members.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold for the number of public methods and attributes in a class"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:36:31.617Z"
   },
   {
     "patternId": "rulesets-codesize.xml-TooManyFields",
-    "title": "Excessive fields",
-    "description": "This pattern reports classes with a high number of fields.",
+    "title": "Refactor Classes with Excessive Fields",
+    "description": "Improve maintainability by redesigning classes with too many fields.",
     "parameters": [
       {
         "name": "maxfields",
         "description": "Reporting threshold for the number of fields in a class"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:36:37.334Z"
   },
   {
     "patternId": "rulesets-codesize.xml-TooManyMethods",
-    "title": "Excessive methods",
-    "description": "This pattern reports classes with a high number of methods.",
+    "title": "Refactor Classes with Excessive Methods",
+    "description": "Classes with too many methods require refactoring",
     "parameters": [
       {
         "name": "maxmethods",
         "description": "Reporting threshold for the number of methods in a class"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:36:44.282Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveClassComplexity",

docs/description/rulesets-cleancode.xml-ElseExpression.md

@@ -1,30 +1,16 @@
-
-Instead of using an else block, you can use an early return statement:
-
-    class Foo
+Improves readability by using early returns instead of else blocks to handle conditions more explicitly. Refactor code accordingly for better maintenance.
+```php
+class Foo 
+{
+    public function bar($flag)
     {
-        public function bar($flag)
-        {
-            if ($flag) {
-                // one branch
-            } else {
-                // another branch
-            }
+        if ($flag) {
+            // one branch
+            return;
         }
+        // another branch
     }
+}
+```
 
-Rewrite without the else:
-
-    class Foo
-    {
-        public function bar($flag)
-        {
-            if ($flag) {
-                // one branch
-                return;
-            }
-
-            // another branch
-        }
-    }
-      
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:35:52.861Z -->

docs/description/rulesets-cleancode.xml-StaticAccess.md

@@ -1,6 +1,15 @@
+Static access increases dependencies and results in code that is hard to test. Instead, inject dependencies through the constructor. For example, avoid using `self::method()` and use constructor injection:
+```
+class Example {
+   private $dependency;
+   public function __construct(Dependency $dependency) {
+      $this->dependency = $dependency;
+   }
 
- Static access increases dependencies and leads to hard to test code. You should instead
- inject dependencies through the constructor
+   public function exampleMethod() {
+      $this->dependency->method();
+   }
+}
+```
 
- [Source](http://phpmd.org/rules/cleancode.html#staticaccess)
-      
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:35:59.524Z -->

docs/description/rulesets-codesize.xml-CyclomaticComplexity.md

@@ -1,18 +1,14 @@
-
-Cyclomatic complexity is determined by the number of decision points in a method plus one for the method entry.
-The following keywords create new decision points: 'if', 'while', 'for', and 'case labels'. For example, this
-code has a cyclomatic complexity level of 2:
-
-    function foo()
-    {
-        $t=date("H");
-        if ($t<"20")
-        {
-            echo "Have a good day!";
-        }
+Cyclomatic complexity quantifies method complexity based on decision points like 'if' and 'for' statements. Scores range: 1-4 (low), 5-7 (medium), 8-10 (high), 11+ (very high). Simplify highly complex methods to improve maintainability and readability.
+
+Example:
+```
+function foo() {
+    $t = date("H");
+    if ($t < "20") {
+        echo "Have a good day!";
     }
+}
+// Cyclomatic Complexity = 2
+```
 
-1-4 indicates low complexity, 5-7 medium complexity, 8-10 high complexity and 11+ indicates very high complexity.
-
-[Source](http://phpmd.org/rules/codesize.html#cyclomaticcomplexity)
-      
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:36:04.929Z -->

docs/description/rulesets-codesize.xml-ExcessiveClassLength.md

@@ -1,6 +1,16 @@
+Long Class files suggest that the class might handle too many responsibilities. Consider breaking it down into smaller classes to enhance manageability and readability. 
 
-Long Class files are an indicator that the class may be trying to do too much.
-Try to break it down, and reduce the size to something manageable.
+Example:
+```php
+// Too Long
+class AdvertTest {
+    // 1026 lines of code
+}
 
-[Source](http://phpmd.org/rules/codesize.html#excessiveclasslength)
-      
+// Improved
+class AdvertTest {
+    // Splitting logic into multiple, focused classes
+}
+```
+
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:36:22.011Z -->

docs/description/rulesets-codesize.xml-ExcessiveMethodLength.md

@@ -1,6 +1,24 @@
+Long methods can signal that a method is tasked with too much. To improve readability and maintainability, divide it into smaller, focused methods. For example:
 
-Long methods are an indicator that the method is doing too much.
-Try to break it down, and reduce the size to something manageable.
+```php
+// Problematic code
+function calculate() {
+    // ... many lines of code
+}
 
-[Source](http://phpmd.org/rules/codesize.html#excessivemethodlength)
-      
+// Improved code
+function calculate() {
+    calculatePartA();
+    calculatePartB();
+}
+
+function calculatePartA() {
+    // logic for part A
+}
+
+function calculatePartB() {
+    // logic for part B
+}
+```
+
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:36:18.001Z -->

docs/description/rulesets-codesize.xml-ExcessiveParameterList.md

@@ -1,5 +1,18 @@
+Long parameter lists indicate that creating a new object to encapsulate the parameters may be beneficial. This enhances code readability and manageability. For example, replace:
+```php
+function createUser($firstName, $lastName, $email, $age) {}
+```
+with:
+```php
+class UserInfo {
+    public $firstName;
+    public $lastName;
+    public $email;
+    public $age;
+    // Constructor and other methods...
+}
 
-Long parameter lists can indicate that a new object should be created to wrap the numerous parameters.
+function createUser(UserInfo $userInfo) {}
+```
 
-[Source](http://phpmd.org/rules/codesize.html#excessiveparameterlist)
-      
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:36:26.426Z -->

docs/description/rulesets-codesize.xml-ExcessivePublicCount.md

@@ -1,7 +1,19 @@
+A class with many public methods and attributes often needs splitting to simplify testing and maintenance. Consider breaking it into smaller classes with focused responsibilities.
+```php
+class TooManyPublicMembers {
+    public $attr1;
+    public $attr2;
+    // many more public attributes
 
-A large number of public methods and attributes declared in a class can indicate
-the class may need to be broken up. Properly testing a class with a large number of
-publicly exposed members is difficult and time consuming.
+    public function method1() {}
+    public function method2() {}
+    // many more public methods
+}
 
-[Source](http://phpmd.org/rules/codesize.html#excessivepubliccount)
-      
+// Refactor to:
+class GroupedResponsibility {
+    // fewer public members
+}
+```
+
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:36:31.617Z -->