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": "Prefer Early Return Over Else Blocks",
+    "description": "Encourage early returns instead of else blocks for clarity.",
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:53:40.117Z"
   },
   {
     "patternId": "rulesets-cleancode.xml-StaticAccess",
-    "title": "Avoid static access",
-    "description": "Static access leads to hard to test code",
+    "title": "Avoid Static Access",
+    "description": "Static access increases dependencies and reduces testability.",
     "timeToFix": 15,
     "parameters": [
       {
         "name": "exceptions",
         "description": "Comma-separated class name list of exceptions"
       }
-    ]
+    ],
+    "patPatBotReviewed": "2024-05-23T14:53:46.190Z"
   },
   {
     "patternId": "rulesets-codesize.xml-CyclomaticComplexity",
-    "title": "Cyclomatic complexity",
-    "description": "This pattern reports methods with high cyclomatic complexity",
+    "title": "Cyclomatic Complexity Evaluation",
+    "description": "Assess complexity based on decision points.",
     "parameters": [
       {
         "name": "reportLevel",
@@ -35,91 +37,99 @@
         "description": "Indicate if method average violation should be included"
       }
     ],
-    "timeToFix": 30
+    "timeToFix": 30,
+    "patPatBotReviewed": "2024-05-23T14:53:57.443Z"
   },
   {
     "patternId": "rulesets-codesize.xml-NPathComplexity",
-    "title": "NPath complexity",
-    "description": "This pattern reports methods with a large number of possible paths",
+    "title": "NPath Complexity in Code Methods",
+    "description": "Measures possible execution paths in methods.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold"
       }
     ],
-    "timeToFix": 30
+    "timeToFix": 30,
+    "patPatBotReviewed": "2024-05-23T14:54:03.492Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveMethodLength",
-    "title": "Excessive method length",
-    "description": "This pattern reports excessively long methods.",
+    "title": "Break Down Long Methods",
+    "description": "Long methods indicate potential over-complexity; simplify them.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold for the number of lines in a method"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:54:07.770Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveClassLength",
-    "title": "Excessive class length",
-    "description": "This pattern reports excessively long classes.",
+    "title": "Class Exceeds Recommended Length",
+    "description": "Indicates a class is too lengthy and complex.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold for the number of lines in a class"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:54:12.269Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveParameterList",
-    "title": "Excessive parameters",
-    "description": "This pattern reports methods with a high number of parameters.",
+    "title": "Refactor Long Parameter Lists",
+    "description": "New object to wrap numerous parameters.",
     "parameters": [
       {
         "name": "minimum",
         "description": "Reporting threshold for the number of arguments in a method"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:54:18.537Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessivePublicCount",
-    "title": "Excessive public attributes",
-    "description": "This pattern reports classes with a high number of public methods and attributes.",
+    "title": "Excessive Public Members in Class",
+    "description": "Break up classes with too many 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:54:24.033Z"
   },
   {
     "patternId": "rulesets-codesize.xml-TooManyFields",
-    "title": "Excessive fields",
-    "description": "This pattern reports classes with a high number of fields.",
+    "title": "Maintainability Concerns with Excessive Class Fields",
+    "description": "Redesign 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:54:30.033Z"
   },
   {
     "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": "Reduce complexity by refactoring classes with too many methods.",
     "parameters": [
       {
         "name": "maxmethods",
         "description": "Reporting threshold for the number of methods in a class"
       }
     ],
-    "timeToFix": 15
+    "timeToFix": 15,
+    "patPatBotReviewed": "2024-05-23T14:54:35.909Z"
   },
   {
     "patternId": "rulesets-codesize.xml-ExcessiveClassComplexity",

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

@@ -1,30 +1,14 @@
-
-Instead of using an else block, you can use an early return statement:
-
-    class Foo
-    {
-        public function bar($flag)
-        {
-            if ($flag) {
-                // one branch
-            } else {
-                // another branch
-            }
+Using early returns in place of else blocks enhances code readability by reducing nesting. This approach facilitates easier comprehension and maintenance of the code.
+```php
+class Foo {
+    public function bar($flag) {
+        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:53:40.117Z -->

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

@@ -1,6 +1,25 @@
+Static access increases code dependencies and hinders testability. Instead, inject dependencies through the constructor to promote flexibility. For example:
 
- Static access increases dependencies and leads to hard to test code. You should instead
- inject dependencies through the constructor
+```php
+// Issue
+class Example {
+    public function doSomething() {
+        Logger::log('message');
+    }
+}
 
- [Source](http://phpmd.org/rules/cleancode.html#staticaccess)
-      
+// Solution
+class Example {
+    private $logger;
+
+    public function __construct(Logger $logger) {
+        $this->logger = $logger;
+    }
+
+    public function doSomething() {
+        $this->logger->log('message');
+    }
+}
+```
+
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:53:46.190Z -->

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

@@ -1,18 +1,12 @@
+Cyclomatic complexity measures the decision points in a method plus one for the method entry. Low complexity (1-4) is preferred, while very high (11+) necessitates refactoring. Address complex methods using helper methods and refactoring. Example:
 
-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!";
-        }
+```php
+function foo() {
+    $t = date("H");
+    if ($t < "20") {
+        echo "Have a good day!";
     }
+}
+```
 
-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:53:57.443Z -->

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

@@ -1,6 +1,19 @@
+A lengthy class file suggests it may be taking on too much responsibility. Refactor the class by breaking it down into smaller, more manageable units. 
 
-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
+// Problematic Class
+class LargeClass {
+    // many methods and properties
+}
 
-[Source](http://phpmd.org/rules/codesize.html#excessiveclasslength)
-      
+// Refactored Code
+class SmallerClass1 {
+    // fewer methods and properties
+}
+class SmallerClass2 {
+    // fewer methods and properties
+}
+```
+
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:54:12.269Z -->

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

@@ -1,6 +1,3 @@
+Long methods often suggest that too much logic is encapsulated in one place. To improve code readability and maintainability, break down long methods into smaller helper methods. This reduces complexity and makes the code cleaner and easier to manage.
 
-Long methods are an indicator that the method is doing too much.
-Try to break it down, and reduce the size to something manageable.
-
-[Source](http://phpmd.org/rules/codesize.html#excessivemethodlength)
-      
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:54:07.770Z -->

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

@@ -1,5 +1,24 @@
+Long parameter lists can be a sign that your method requires too many inputs, making it hard to maintain and understand. Consider creating a new object that encapsulates these numerous parameters. For example:
+```
+// Problematic Code
+function bookTicket($flightNumber, $departureDate, $returnDate, $passengerName, $seatPreference) {
+    ...
+}
 
-Long parameter lists can indicate that a new object should be created to wrap the numerous parameters.
+// Refactored Code
+class TicketDetails {
+    public $flightNumber;
+    public $departureDate;
+    public $returnDate;
+    public $passengerName;
+    public $seatPreference;
+    
+    // constructor and other methods
+}
 
-[Source](http://phpmd.org/rules/codesize.html#excessiveparameterlist)
-      
+function bookTicket(TicketDetails $ticketDetails) {
+    ...
+}
+```
+
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:54:18.537Z -->

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

@@ -1,7 +1,21 @@
+A large number of public methods and attributes in a class can indicate it needs to be broken up. This complexity makes thorough testing difficult and time-consuming. Consider refactoring the class to reduce the number of public members. 
+Example:
+```php
+// Avoid
+class ComplexClass {
+    public function method1() {}
+    public function method2() {}
+    // ... many more methods and 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.
+// Refactor to
+class SimplifiedClass {
+    public function method1() {}
+}
 
-[Source](http://phpmd.org/rules/codesize.html#excessivepubliccount)
-      
+class AnotherClass {
+    public function method2() {}
+}
+```
+
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:54:24.033Z -->

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

@@ -1,26 +1,15 @@
-
-NPath complexity measures all the possible code paths in your methods. For example, the following method has NPath complexity of 8:
-
-
-    function foo($value) {
-        $result = '';
-
-        if($value % 3 == 0) {
-            $result .= 'divisible by 3';
-        }
-
-        if($value % 5 == 0) {
-            $result .= 'divisible by 5';
-        }
-
-        if(!$result) {
-            $result = $value;
-        }
-
-        return $result;
+NPath complexity is the count of execution paths in a method. Methods exceeding an NPath complexity of 200 should be refactored to improve maintainability. For example, nested conditions create multiple paths.
+
+```php
+function example($value) {
+    if ($value > 0 && $value < 10) {
+        return 'single digit';
+    } elseif ($value >= 10 && $value < 100) {
+        return 'double digits';
+    } else {
+        return 'other';
     }
+}
+```
 
-As a rule of thumb, methods with NPath complexity higher than 200 should be refactored.
-
-[Source](http://phpmd.org/rules/codesize.html#npathcomplexity)
-      
+<!-- Codacy PatPatBot reviewed: 2024-05-23T14:54:03.492Z -->