http_endpoint: decompose string ctor under the CCN 10 bar (22 -> 7)

http_endpoint::http_endpoint(const string&, bool, bool, bool) was a
75-line registration-time URL parser doing case-insensitive lowercase,
slash normalization, per-piece dispatch between non-registration /
literal / parameter modes, and optional regex compilation. CCN 22.

Decomposed into private member helpers:

  normalize_url_complete             trim trailing '/', ensure leading '/'
  process_url_part                   per-iteration mode dispatch
    append_non_registration_part      verbatim push to url_pieces
    append_literal_url_part           literal piece, respect '^' anchor
    append_parameter_url_part         "{name}" / "{name|regex}" parse
  compile_regex_url                  trailing '$' + std::regex compile

The ctor itself drops to CCN 7: throw-if-regex-without-registration,
seed url_normalized, lowercase if CASE_INSENSITIVE, normalize slashes,
tokenize, loop over parts calling process_url_part, compile_regex if
requested. Every new helper sits at CCN <= 7.

Behaviour preserved verbatim: the leading-'^' anchor on the first
literal piece still REPLACES url_normalized's seed (rather than
appending), the parameter-mode validation still throws on parts of
size <3 or missing braces, and compile_regex_url still throws via
the same std::regex::extended | icase | nosubs path.

Verified locally: full `make check`.

scripts/check-complexity.sh CCN_MAX ratcheted 23 -> 22 (the new worst
offender is webserver_impl::post_iterator at CCN 21).

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

Author: etr

scripts/check-complexity.sh

@@ -27,7 +27,7 @@
 set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-CCN_MAX="${CCN_MAX:-23}"
+CCN_MAX="${CCN_MAX:-22}"
 
 # Prefer the standalone `lizard` entrypoint if it's on PATH; fall back to
 # `python3 -m lizard` which is what `pip install --user lizard` produces

src/detail/http_endpoint.cpp

@@ -42,80 +42,95 @@ namespace detail {
 http_endpoint::~http_endpoint() {
 }
 
+void http_endpoint::normalize_url_complete() {
+    if (url_complete[url_complete.size() - 1] == '/') {
+        url_complete = url_complete.substr(0, url_complete.size() - 1);
+    }
+    if (url_complete[0] != '/') {
+        url_complete = "/" + url_complete;
+    }
+}
+
+void http_endpoint::append_non_registration_part(const string& part, bool& first) {
+    url_normalized += (first ? "" : "/") + part;
+    first = false;
+    url_pieces.push_back(part);
+}
+
+void http_endpoint::append_literal_url_part(const string& part, bool& first) {
+    if (first) {
+        // First piece: respect a leading '^' anchor verbatim by replacing
+        // (not appending to) url_normalized's seed prefix.
+        url_normalized = (part[0] == '^' ? "" : url_normalized) + part;
+        first = false;
+    } else {
+        url_normalized += "/" + part;
+    }
+    url_pieces.push_back(part);
+}
+
+void http_endpoint::append_parameter_url_part(const string& part,
+                                              unsigned int i, bool& first) {
+    if (part.size() < 3 || part[0] != '{' || part[part.size() - 1] != '}') {
+        throw std::invalid_argument("Bad URL format");
+    }
+    // {name} or {name|regex}: split on the optional '|'.
+    std::string::size_type bar = part.find_first_of('|');
+    const bool has_regex = bar != string::npos;
+    url_pars.push_back(part.substr(1, has_regex ? bar - 1 : part.size() - 2));
+    url_normalized += (first ? "" : "/")
+        + (has_regex ? part.substr(bar + 1, part.size() - bar - 2) : "([^\\/]+)");
+    first = false;
+    chunk_positions.push_back(i);
+    url_pieces.push_back(part);
+}
+
+void http_endpoint::process_url_part(const vector<string>& parts,
+                                     unsigned int i, bool& first, bool registration) {
+    if (!registration) {
+        append_non_registration_part(parts[i], first);
+        return;
+    }
+    if (!parts[i].empty() && parts[i][0] != '{') {
+        append_literal_url_part(parts[i], first);
+        return;
+    }
+    append_parameter_url_part(parts[i], i, first);
+}
+
+void http_endpoint::compile_regex_url() {
+    url_normalized += "$";
+    try {
+        re_url_normalized = std::regex(url_normalized,
+            std::regex::extended | std::regex::icase | std::regex::nosubs);
+    } catch (std::regex_error& e) {
+        throw std::invalid_argument("Not a valid regex in URL: " + url_normalized);
+    }
+    reg_compiled = true;
+}
+
 http_endpoint::http_endpoint(const string& url, bool family, bool registration, bool use_regex):
     family_url(family),
     reg_compiled(false) {
     if (use_regex && !registration) {
         throw std::invalid_argument("Cannot use regex if not during registration");
     }
-
     url_normalized = use_regex ? "^/" : "/";
-    vector<string> parts;
 
 #ifdef CASE_INSENSITIVE
     string_utilities::to_lower_copy(url, url_complete);
 #else
     url_complete = url;
 #endif
+    normalize_url_complete();
 
-    if (url_complete[url_complete.size() - 1] == '/') {
-        url_complete = url_complete.substr(0, url_complete.size() - 1);
-    }
-
-    if (url_complete[0] != '/') {
-        url_complete = "/" + url_complete;
-    }
-
-    parts = httpserver::http::http_utils::tokenize_url(url);
-    string buffered;
+    auto parts = httpserver::http::http_utils::tokenize_url(url);
     bool first = true;
-
     for (unsigned int i = 0; i < parts.size(); i++) {
-        if (!registration) {
-            url_normalized += (first ? "" : "/") + parts[i];
-            first = false;
-
-            url_pieces.push_back(parts[i]);
-
-            continue;
-        }
-
-        if ((parts[i] != "") && (parts[i][0] != '{')) {
-            if (first) {
-                url_normalized = (parts[i][0] == '^' ? "" : url_normalized) + parts[i];
-                first = false;
-            } else {
-                url_normalized += "/" + parts[i];
-            }
-            url_pieces.push_back(parts[i]);
-
-            continue;
-        }
-
-        if ((parts[i].size() < 3) || (parts[i][0] != '{') || (parts[i][parts[i].size() - 1] != '}')) {
-            throw std::invalid_argument("Bad URL format");
-        }
-
-        std::string::size_type bar = parts[i].find_first_of('|');
-        url_pars.push_back(parts[i].substr(1, bar != string::npos ? bar - 1 : parts[i].size() - 2));
-        url_normalized += (first ? "" : "/") + (bar != string::npos ? parts[i].substr(bar + 1, parts[i].size() - bar - 2) : "([^\\/]+)");
-
-        first = false;
-
-        chunk_positions.push_back(i);
-
-        url_pieces.push_back(parts[i]);
+        process_url_part(parts, i, first, registration);
     }
 
-    if (use_regex) {
-        url_normalized += "$";
-        try {
-            re_url_normalized = std::regex(url_normalized, std::regex::extended | std::regex::icase | std::regex::nosubs);
-        } catch (std::regex_error& e) {
-            throw std::invalid_argument("Not a valid regex in URL: " + url_normalized);
-        }
-        reg_compiled = true;
-    }
+    if (use_regex) compile_regex_url();
 }
 
 http_endpoint::http_endpoint(const http_endpoint& h):

src/httpserver/detail/http_endpoint.hpp

@@ -186,6 +186,20 @@ class http_endpoint {
       * Boolean indicating if the regex is compiled
      **/
      bool reg_compiled;
+
+     // Sub-helpers carved out of the string-ctor to keep each function
+     // under the cyclomatic-complexity bar. process_url_part dispatches
+     // per-iteration between the three modes (non-registration / literal
+     // / parameter), each of which appends its own piece to url_normalized,
+     // url_pieces, and (for parameters) url_pars + chunk_positions.
+     void normalize_url_complete();
+     void process_url_part(const std::vector<std::string>& parts,
+                           unsigned int i, bool& first, bool registration);
+     void append_non_registration_part(const std::string& part, bool& first);
+     void append_literal_url_part(const std::string& part, bool& first);
+     void append_parameter_url_part(const std::string& part,
+                                    unsigned int i, bool& first);
+     void compile_regex_url();
 };
 
 }  // namespace detail