TASK-022: snake_case render_* overrides on http_resource

Pure rename. The nine virtual member functions on http_resource are
now snake_case to match the public API style established by TASK-001:

  render_GET     -> render_get
  render_POST    -> render_post
  render_PUT     -> render_put
  render_DELETE  -> render_delete
  render_PATCH   -> render_patch
  render_OPTIONS -> render_options
  render_HEAD    -> render_head
  render_CONNECT -> render_connect
  render_TRACE   -> render_trace

The default render(...) fallback signature is unchanged.

Decision: this PR keeps the existing std::shared_ptr<http_response>
return type. The action item that calls for "http_response by value"
is the architectural turf of TASK-036, which already lists the dispatch
flip (modded_request::dhrs, internal_error_page, the auth path,
deferred-response lifetime) in its own action items and references the
already-renamed snake_case names in its acceptance criteria. Pulling
the value-return cutover into TASK-022 would force a transitional
shim because TASK-025/027/031 (which TASK-036 also depends on) have
not landed yet. Rename now; flip return type in TASK-036.

No compatibility shim. v2.0 is a clean break (PRD-NAM-REQ-001, §3.7,
§4.4, TASK-042). Subclasses still using the old camelCase names will
silently produce non-overriding shadow methods - that is the user's
signal to read the migration guide.

Acceptance:
- grep -E 'render_[A-Z]' src/httpserver/*.hpp returns empty
- Wider sweep (src/, test/, examples/, README.md, doc/) returns empty
- All 32 testsuite entries pass under release build
- All 32 testsuite entries pass under --enable-debug (-Werror -Wextra)
- cpplint clean on changed files

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: etr

README.md

@@ -561,14 +561,14 @@ Once a webserver is created, you can manage its execution through the following
 The `http_resource` class represents a logical collection of HTTP methods that will be associated to a URL when registered on the webserver. The class is **designed for extension** and it is where most of your code should ideally live. When the webserver matches a request against a resource (see: [resource registration](#registering-resources)), the method correspondent to the one in the request (GET, POST, etc..) (see below) is called on the resource.
 
 Given this, the `http_resource` class contains the following extensible methods (also called `handlers` or `render methods`):
-* _**std::shared_ptr<http_response>** http_resource::render_GET(**const http_request&** req):_ Invoked on an HTTP GET request.
-* _**std::shared_ptr<http_response>** http_resource::render_POST(**const http_request&** req):_ Invoked on an HTTP POST request.
-* _**std::shared_ptr<http_response>** http_resource::render_PUT(**const http_request&** req):_ Invoked on an HTTP PUT request.
-* _**std::shared_ptr<http_response>** http_resource::render_HEAD(**const http_request&** req):_ Invoked on an HTTP HEAD request.
-* _**std::shared_ptr<http_response>** http_resource::render_DELETE(**const http_request&** req):_ Invoked on an HTTP DELETE request.
-* _**std::shared_ptr<http_response>** http_resource::render_TRACE(**const http_request&** req):_ Invoked on an HTTP TRACE request.
-* _**std::shared_ptr<http_response>** http_resource::render_OPTIONS(**const http_request&** req):_ Invoked on an HTTP OPTIONS request.
-* _**std::shared_ptr<http_response>** http_resource::render_CONNECT(**const http_request&** req):_ Invoked on an HTTP CONNECT request.
+* _**std::shared_ptr<http_response>** http_resource::render_get(**const http_request&** req):_ Invoked on an HTTP GET request.
+* _**std::shared_ptr<http_response>** http_resource::render_post(**const http_request&** req):_ Invoked on an HTTP POST request.
+* _**std::shared_ptr<http_response>** http_resource::render_put(**const http_request&** req):_ Invoked on an HTTP PUT request.
+* _**std::shared_ptr<http_response>** http_resource::render_head(**const http_request&** req):_ Invoked on an HTTP HEAD request.
+* _**std::shared_ptr<http_response>** http_resource::render_delete(**const http_request&** req):_ Invoked on an HTTP DELETE request.
+* _**std::shared_ptr<http_response>** http_resource::render_trace(**const http_request&** req):_ Invoked on an HTTP TRACE request.
+* _**std::shared_ptr<http_response>** http_resource::render_options(**const http_request&** req):_ Invoked on an HTTP OPTIONS request.
+* _**std::shared_ptr<http_response>** http_resource::render_connect(**const http_request&** req):_ Invoked on an HTTP CONNECT request.
 * _**std::shared_ptr<http_response>** http_resource::render(**const http_request&** req):_ Invoked as a backup method if the matching method is not implemented. It can be used whenever you want all the invocations on a URL to activate the same behavior regardless of the HTTP method requested. The default implementation of the `render` method returns an empty response with a `404`.
 
 #### Example of implementation of render methods
@@ -579,7 +579,7 @@ Given this, the `http_resource` class contains the following extensible methods
 
     class hello_world_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             return std::shared_ptr<http_response>(new string_response("GET: Hello, World!"));
         }
 
@@ -913,7 +913,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class image_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             // binary_data could come from a camera capture, image library, etc.
             std::string binary_data = get_image_bytes_from_camera();
 
@@ -1014,7 +1014,7 @@ Client certificate authentication uses a X.509 certificate from the client. This
 
     class user_pass_resource : public httpserver::http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request& req) {
+        std::shared_ptr<http_response> render_get(const http_request& req) {
             if (req.get_user() != "myuser" || req.get_pass() != "mypass") {
                 return std::shared_ptr<basic_auth_fail_response>(new basic_auth_fail_response("FAIL", "test@example.com"));
             }
@@ -1060,7 +1060,7 @@ You can also use `check_digest_auth_digest` to verify against a pre-computed HA1
 
     class digest_resource : public httpserver::http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request& req) {
+        std::shared_ptr<http_response> render_get(const http_request& req) {
             if (req.get_digested_user() == "") {
                 return std::make_shared<digest_auth_fail_response>("FAIL", "test@example.com", MY_OPAQUE, true,
                     http_utils::http_ok, http_utils::text_plain, http_utils::digest_algorithm::MD5);
@@ -1112,14 +1112,14 @@ libhttpserver provides a centralized authentication mechanism that runs a single
     // Resources no longer need authentication logic
     class hello_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             return std::make_shared<string_response>("Hello, authenticated user!", 200, "text/plain");
         }
     };
 
     class health_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             return std::make_shared<string_response>("OK", 200, "text/plain");
         }
     };
@@ -1185,7 +1185,7 @@ To enable client certificate authentication, configure your webserver with:
 
     class secure_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request& req) {
+        std::shared_ptr<http_response> render_get(const http_request& req) {
             // Check if client provided a certificate
             if (!req.has_client_certificate()) {
                 return std::make_shared<string_response>(
@@ -1409,7 +1409,7 @@ Additionally, the following utility methods are available:
 
     class file_response_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request& req) {
+        std::shared_ptr<http_response> render_get(const http_request& req) {
             return std::shared_ptr<file_response>(new file_response("test_content", 200, "text/plain"));
         }
     };
@@ -1452,7 +1452,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class deferred_resource : public http_resource {
         public:
-            std::shared_ptr<http_response> render_GET(const http_request& req) {
+            std::shared_ptr<http_response> render_get(const http_request& req) {
                 return std::shared_ptr<deferred_response<void> >(new deferred_response<void>(test_callback, nullptr, "cycle callback response"));
             }
     };
@@ -1509,7 +1509,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
     
     class deferred_resource : public http_resource {
         public:
-            std::shared_ptr<http_response> render_GET(const http_request& req) {
+            std::shared_ptr<http_response> render_get(const http_request& req) {
                 std::shared_ptr<std::atomic<int> > closure_data(new std::atomic<int>(counter++));
                 return std::shared_ptr<deferred_response<std::atomic<int> > >(new deferred_response<std::atomic<int> >(test_callback, closure_data, "cycle callback response"));
             }
@@ -1539,13 +1539,13 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class no_content_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_DELETE(const http_request&) {
+        std::shared_ptr<http_response> render_delete(const http_request&) {
             // Return a 204 No Content response with no body
             return std::make_shared<empty_response>(
                     http::http_utils::http_no_content);
         }
 
-        std::shared_ptr<http_response> render_HEAD(const http_request&) {
+        std::shared_ptr<http_response> render_head(const http_request&) {
             // Return a HEAD-only response with headers but no body
             auto response = std::make_shared<empty_response>(
                     http::http_utils::http_ok,
@@ -1580,7 +1580,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class iovec_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             // Build a response from multiple separate buffers without copying
             std::vector<std::string> parts;
             parts.push_back("{\"header\": \"value\", ");
@@ -1619,7 +1619,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class pipe_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             int pipefd[2];
             if (pipe(pipefd) == -1) {
                 return std::make_shared<string_response>("pipe failed", 500);
@@ -1704,7 +1704,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class hello_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             return std::make_shared<string_response>("Hello, World!");
         }
     };
@@ -1748,7 +1748,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class hello_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             return std::make_shared<string_response>("Hello from external event loop!");
         }
     };
@@ -1793,7 +1793,7 @@ You can also check this example on [github](https://github.com/etr/libhttpserver
 
     class hello_resource : public http_resource {
     public:
-        std::shared_ptr<http_response> render_GET(const http_request&) {
+        std::shared_ptr<http_response> render_get(const http_request&) {
             return std::make_shared<string_response>("Hello, turbo world!");
         }
     };

examples/basic_authentication.cpp

@@ -25,7 +25,7 @@
 
 class user_pass_resource : public httpserver::http_resource {
  public:
-     std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request& req) {
+     std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request& req) {
          if (req.get_user() != "myuser" || req.get_pass() != "mypass") {
              return std::make_shared<httpserver::http_response>(
                  httpserver::http_response::unauthorized("Basic", "test@example.com", "FAIL"));

examples/binary_buffer_response.cpp

@@ -58,7 +58,7 @@ static std::string generate_png_data() {
 
 class image_resource : public httpserver::http_resource {
  public:
-    std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request&) {
+    std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request&) {
         // Build binary content as a std::string. The string can contain any
         // bytes — it is not limited to printable characters or null-terminated
         // C strings. The size is tracked internally by std::string::size().

examples/centralized_authentication.cpp

@@ -31,14 +31,14 @@ using httpserver::create_webserver;
 // Simple resource that doesn't need to handle auth itself
 class hello_resource : public http_resource {
  public:
-    std::shared_ptr<http_response> render_GET(const http_request&) {
+    std::shared_ptr<http_response> render_get(const http_request&) {
         return std::make_shared<http_response>(http_response::string("Hello, authenticated user!"));
     }
 };
 
 class health_resource : public http_resource {
  public:
-    std::shared_ptr<http_response> render_GET(const http_request&) {
+    std::shared_ptr<http_response> render_get(const http_request&) {
         return std::make_shared<http_response>(http_response::string("OK"));
     }
 };

examples/client_cert_auth.cpp

@@ -67,7 +67,7 @@ std::set<std::string> allowed_fingerprints;
 // Resource that requires client certificate authentication
 class secure_resource : public httpserver::http_resource {
  public:
-    std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request& req) {
+    std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request& req) {
         // Check if client provided a certificate
         if (!req.has_client_certificate()) {
             return std::make_shared<httpserver::http_response>(httpserver::http_response::string("Client certificate required").with_status(httpserver::http::http_utils::http_unauthorized));
@@ -123,7 +123,7 @@ class secure_resource : public httpserver::http_resource {
 // Public resource that shows certificate info but doesn't require it
 class info_resource : public httpserver::http_resource {
  public:
-    std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request& req) {
+    std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request& req) {
         std::string response;
 
         if (req.has_client_certificate()) {

examples/daemon_info.cpp

@@ -25,7 +25,7 @@
 
 class hello_resource : public httpserver::http_resource {
  public:
-     std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request&) {
+     std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request&) {
          return std::make_shared<httpserver::http_response>(httpserver::http_response::string("Hello, World!"));
      }
 };

examples/deferred_with_accumulator.cpp

@@ -61,7 +61,7 @@ ssize_t test_callback(std::shared_ptr<std::atomic<int> > closure_data, char* buf
 
 class deferred_resource : public httpserver::http_resource {
  public:
-     std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request&) {
+     std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request&) {
          std::shared_ptr<std::atomic<int> > closure_data(new std::atomic<int>(counter++));
          std::string initial = "cycle callback response";
          return std::make_shared<httpserver::http_response>(

examples/digest_authentication.cpp

@@ -26,7 +26,7 @@
 
 class digest_resource : public httpserver::http_resource {
  public:
-     std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request& req) {
+     std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request& req) {
          using httpserver::http::http_utils;
          if (req.get_digested_user() == "") {
              return std::make_shared<httpserver::http_response>(httpserver::http_response::unauthorized("Digest", "test@example.com", "FAIL"));

examples/empty_response_example.cpp

@@ -26,13 +26,13 @@
 
 class no_content_resource : public httpserver::http_resource {
  public:
-     std::shared_ptr<httpserver::http_response> render_DELETE(const httpserver::http_request&) {
+     std::shared_ptr<httpserver::http_response> render_delete(const httpserver::http_request&) {
          // Return a 204 No Content response with no body
          return std::make_shared<httpserver::http_response>(
              httpserver::http_response::empty());
      }
 
-     std::shared_ptr<httpserver::http_response> render_HEAD(const httpserver::http_request&) {
+     std::shared_ptr<httpserver::http_response> render_head(const httpserver::http_request&) {
          // Return a HEAD-only response with headers but no body
          auto response = std::make_shared<httpserver::http_response>(
              httpserver::http_response::empty(MHD_RF_HEAD_ONLY_RESPONSE)

examples/external_event_loop.cpp

@@ -33,7 +33,7 @@ void signal_handler(int) {
 
 class hello_resource : public httpserver::http_resource {
  public:
-     std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request&) {
+     std::shared_ptr<httpserver::http_response> render_get(const httpserver::http_request&) {
          return std::make_shared<httpserver::http_response>(httpserver::http_response::string("Hello from external event loop!"));
      }
 };