style: format code for consistency and readability in validation rules

webserv/config/validation/structural_rules/RequiredLocationBlocksRule.cpp

@@ -6,8 +6,9 @@
 #include <string>
 
 RequiredLocationBlocksRule::RequiredLocationBlocksRule(size_t minimumLocations)
-    : AStructuralValidationRule("RequiredLocationBlocksRule",
+    : AStructuralValidationRule("RequiredLocationBlocksRule", "Ensures server has at least " +
-                                "Ensures server has at least " + std::to_string(minimumLocations) + " location block(s)"),
+                                                                  std::to_string(minimumLocations) +
+                                                                  " location block(s)"),
       minimumLocations_(minimumLocations)
 {
 }
@@ -16,16 +17,17 @@ ValidationResult RequiredLocationBlocksRule::validateServer(const ServerConfig *
 {
     Log::trace(LOCATION);
 
-    if (config == nullptr) {
+    if (config == nullptr)
+    {
         return ValidationResult::error("Server config is null");
     }
 
     size_t locationCount = config->getLocationPaths().size();
 
-    if (locationCount < minimumLocations_) {
+    if (locationCount < minimumLocations_)
-        return ValidationResult::error(
+    {
-            "Server block must have at least " + std::to_string(minimumLocations_) +
+        return ValidationResult::error("Server block must have at least " + std::to_string(minimumLocations_) +
-            " location block(s), but found " + std::to_string(locationCount));
+                                       " location block(s), but found " + std::to_string(locationCount));
     }
 
     return ValidationResult::success();

webserv/config/validation/structural_rules/RequiredLocationBlocksRule.hpp

@@ -8,10 +8,10 @@ class ServerConfig;
 
 class RequiredLocationBlocksRule : public AStructuralValidationRule
 {
-private:
+  private:
     size_t minimumLocations_;
 
-public:
+  public:
     explicit RequiredLocationBlocksRule(size_t minimumLocations = 1);
 
     ~RequiredLocationBlocksRule() override = default;

webserv/config/validation/structural_rules/StructuralRules.hpp

@@ -10,27 +10,27 @@
 
 /**
  * Structural Validation Rules for WebServ Configuration
- * 
+ *
  * These rules validate the overall structure and relationships
  * between configuration blocks, rather than individual directive values.
- * 
+ *
  * Available Rules:
- * 
+ *
  * 1. MinimumServerBlocksRule - Ensures global config has minimum number of server blocks
- * 2. RequiredLocationBlocksRule - Ensures each server has minimum number of location blocks  
+ * 2. RequiredLocationBlocksRule - Ensures each server has minimum number of location blocks
  * 3. UniqueServerNamesRule - Ensures all server names are unique across configuration
- * 
+ *
  * Usage:
- * 
+ *
  *   // In ValidationEngine setup
  *   engine.addStructuralRule(std::make_unique<MinimumServerBlocksRule>(1));
  *   engine.addStructuralRule(std::make_unique<RequiredLocationBlocksRule>(1));
  *   engine.addStructuralRule(std::make_unique<UniqueServerNamesRule>());
- * 
+ *
  * Each rule inherits from AStructuralValidationRule and can validate at:
  * - Global level (validateGlobal)
- * - Server level (validateServer) 
+ * - Server level (validateServer)
  * - Location level (validateLocation)
- * 
+ *
  * Rules have descriptive names and descriptions set in their constructors.
  */

webserv/config/validation/structural_rules/UniqueServerNamesRule.cpp

@@ -9,8 +9,7 @@
 #include <string>
 
 UniqueServerNamesRule::UniqueServerNamesRule()
-    : AStructuralValidationRule("UniqueServerNamesRule",
+    : AStructuralValidationRule("UniqueServerNamesRule", "Ensures all server blocks have unique server names")
-                                "Ensures all server blocks have unique server names")
 {
 }
 
@@ -18,27 +17,31 @@ ValidationResult UniqueServerNamesRule::validateGlobal(const GlobalConfig *confi
 {
     Log::trace(LOCATION);
 
-    if (config == nullptr) {
+    if (config == nullptr)
+    {
         return ValidationResult::error("Global config is null");
     }
 
     std::set<std::string> serverNames;
     auto servers = config->getServerConfigs();
 
-    for (const auto *server : servers) {
+    for (const auto *server : servers)
-        if (server == nullptr) {
+    {
+        if (server == nullptr)
+        {
             continue;
         }
 
         auto serverNameOpt = server->get<std::string>("server_name");
         auto listenOpt = server->get<int>("listen");
-        if (serverNameOpt.has_value() && listenOpt.has_value()) {
+        if (serverNameOpt.has_value() && listenOpt.has_value())
+        {
             const std::string &serverName = serverNameOpt.value();
             int listenPort = listenOpt.value();
 
-            if (serverNames.contains(serverName + ":" + std::to_string(listenPort))) {
+            if (serverNames.contains(serverName + ":" + std::to_string(listenPort)))
-                return ValidationResult::error(
+            {
-                    "Duplicate server name '" + serverName + "' found in configuration");
+                return ValidationResult::error("Duplicate server name '" + serverName + "' found in configuration");
             }
 
             serverNames.insert(serverName + ":" + std::to_string(listenPort));

webserv/config/validation/structural_rules/UniqueServerNamesRule.hpp

@@ -6,7 +6,7 @@ class GlobalConfig;
 
 class UniqueServerNamesRule : public AStructuralValidationRule
 {
-public:
+  public:
     UniqueServerNamesRule();
 
     ~UniqueServerNamesRule() override = default;