fix: resolve 10 correctness, safety, and performance issues

1. Prevent infinite recursion in leetify() on unmappable inputs
   (e.g. single consonant "M") by capping recursion at max_depth.

2. Filter empty parts in split_name() so consecutive spaces no
   longer produce empty strings that cause UB in initials(),
   first_plus_initial(), and initial_plus_last().

3. Guard mix_two() against single-character name parts where
   engine.get(2, 1) triggered UB (min > max in distribution).

4. Skip empty lines in parse_file() to prevent empty strings in
   word lists that would cause UB in transforms calling .back().

5. Strip trailing \r in parse_file() for cross-platform
   compatibility with \r\n line endings.

6. Always use name-based generation when a name is provided but
   no word lists are loaded — previously threw 75% of the time.

7. Fix leetify() force-retry to compare against pre-transform
   value instead of _original_string, which was almost never
   equal for name-based nicknames.

8. Switch _engine from mt19937 to mt19937_64 and XOR-fold seeds
   for per-call engines so upper 32 bits are no longer discarded.

9. Move word vector in parse_file() instead of copying it.

10. Replace character-based candidate list in oneleet() with
    position-based selection to eliminate duplicate bias.

Author: dasmig

dasmig/nicknamegen.hpp

@@ -139,8 +139,8 @@ class nng
     {
         auto call_seed = static_cast<std::uint64_t>(_engine());
         effolkronium::random_local call_engine;
-        call_engine.seed(
-            static_cast<std::mt19937::result_type>(call_seed));
+        call_engine.seed(static_cast<std::mt19937::result_type>(
+            (call_seed ^ (call_seed >> 32U))));
         auto result = solver(name, call_engine);
         result._seed = call_seed;
         return result;
@@ -160,8 +160,8 @@ class nng
                                         std::uint64_t call_seed) const
     {
         effolkronium::random_local call_engine;
-        call_engine.seed(
-            static_cast<std::mt19937::result_type>(call_seed));
+        call_engine.seed(static_cast<std::mt19937::result_type>(
+            (call_seed ^ (call_seed >> 32U))));
         auto result = solver(name, call_engine);
         result._seed = call_seed;
         return result;
@@ -179,7 +179,7 @@ class nng
     /// @return `*this` for chaining.
     nng& seed(std::uint64_t seed_value)
     {
-        _engine.seed(static_cast<std::mt19937::result_type>(seed_value));
+        _engine.seed(seed_value);
         return *this;
     }
 
@@ -253,7 +253,7 @@ class nng
     std::vector<word_container> _wordlists;
 
     // Per-instance random engine for seed drawing.
-    std::mt19937 _engine{std::random_device{}()};
+    std::mt19937_64 _engine{std::random_device{}()};
 
     // Tag type for the auto-probing singleton constructor.
     struct auto_probe_tag {};
@@ -420,27 +420,22 @@ class nng
         // Nickname with leetified letter.
         std::wstring leet_nickname{nickname};
 
-        // Candidate letters to be leetified.
-        std::vector<wchar_t> candidates;
+        // Collect indices of leet-mappable characters.
+        std::vector<std::size_t> candidate_positions;
 
-        // Retrieve candidates for replacement.
-        for (const auto& character : leet_nickname)
+        for (std::size_t i = 0; i < leet_nickname.size(); ++i)
         {
-            if (_leet_map.contains(character))
+            if (_leet_map.contains(leet_nickname[i]))
             {
-                candidates.push_back(character);
+                candidate_positions.push_back(i);
             }
         }
 
-        // Pick one candidate at random and replace its first occurrence.
-        if (!candidates.empty())
+        // Pick one position at random and replace it.
+        if (!candidate_positions.empty())
         {
-            auto target = *engine.get(candidates);
-            if (auto it = std::ranges::find(leet_nickname, target);
-                it != leet_nickname.end())
-            {
-                *it = _leet_map.at(target);
-            }
+            auto pos = *engine.get(candidate_positions);
+            leet_nickname[pos] = _leet_map.at(leet_nickname[pos]);
         }
 
         return leet_nickname;
@@ -471,8 +466,12 @@ class nng
     // NOLINTNEXTLINE(misc-no-recursion)
     static nickname leetify(nickname nickname,
                              effolkronium::random_local& engine,
-                             bool force = false)
+                             bool force = false, int depth = 0)
     {
+        // Maximum recursion depth to prevent stack overflow on unmappable
+        // inputs.
+        static constexpr int max_depth{7};
+
         // We have 1/2 chance of leetifying, force parameter overrides this.
         if (force || engine.get<bool>())
         {
@@ -488,32 +487,40 @@ class nng
                     allleet   // n1ckn4m3
                 };
 
+                // Capture pre-transform value to detect no-ops.
+                auto before = nickname._internal_string;
+
                 // New leetified nickname.
                 nickname._internal_string =
                     (*engine.get(
                         possible_generators))(nickname, engine);
 
-                // If the new nickname didn't suffer any alteration, force
-                // leetify again.
-                return leetify(nickname, engine,
-                               nickname._internal_string ==
-                                   nickname._original_string);
+                // If the new nickname didn't change and we haven't exceeded
+                // the depth limit, force leetify again.
+                if (depth < max_depth)
+                {
+                    return leetify(nickname, engine,
+                                   nickname._internal_string == before,
+                                   depth + 1);
+                }
             }
+            else
+            {
+                // Possible methods utilized to leetify the nickname.
+                static const generators possible_generators{
+                    xfy,     // nicknameX
+                    reverse, // emanckin
+                    yfy,     // nicknamy
+                    numify,  // nickname2000
+                    tracefy, // nickname-
+                    ingify,  // nicknaming
+                };
 
-            // Possible methods utilized to leetify the nickname.
-            static const generators possible_generators{
-                xfy,     // nicknameX
-                reverse, // emanckin
-                yfy,     // nicknamy
-                numify,  // nickname2000
-                tracefy, // nickname-
-                ingify,  // nicknaming
-            };
-
-            // New leetified nickname.
-            nickname._internal_string =
-                (*engine.get(possible_generators))(
-                    nickname, engine);
+                // New leetified nickname.
+                nickname._internal_string =
+                    (*engine.get(possible_generators))(
+                        nickname, engine);
+            }
         }
 
         return nickname;
@@ -761,15 +768,20 @@ class nng
     }
 
     // Split a full name into a vector containing each name/surname.
+    // Empty parts (from consecutive spaces) are filtered out.
     [[nodiscard]] static std::vector<std::wstring> split_name(
         const std::wstring& name)
     {
         std::vector<std::wstring> parts;
 
         for (auto part : name | std::views::split(L' '))
         {
-            parts.emplace_back(std::ranges::begin(part),
-                               std::ranges::end(part));
+            std::wstring s(std::ranges::begin(part),
+                           std::ranges::end(part));
+            if (!s.empty())
+            {
+                parts.push_back(std::move(s));
+            }
         }
 
         return parts;
@@ -829,17 +841,25 @@ class nng
         auto names_list{split_name(name)};
 
         // Reduce name list to two names.
-        while (names_list.size() > 2)
+        if (names_list.size() > 2)
         {
-            names_list.erase(names_list.begin());
+            names_list.erase(names_list.begin(),
+                             names_list.end() - 2);
         }
 
         // Iterate through each name retrieving random number of letters.
         for (const auto& name : names_list)
         {
-            nickname.append(name.substr(
-                0, engine.get<std::size_t>(
-                       2, name.size())));
+            if (name.size() < 2)
+            {
+                nickname.append(name);
+            }
+            else
+            {
+                nickname.append(name.substr(
+                    0, engine.get<std::size_t>(
+                           2, name.size())));
+            }
         }
 
         return nickname;
@@ -914,9 +934,16 @@ class nng
         // 1/4 chance of nickname being name related.
         static constexpr double name_related_probability{0.25};
 
+        // When name is provided, use name-based generation with
+        // name_related_probability — but always use the name if there are
+        // no wordlists to fall back to.
+        const bool use_name =
+            !name.empty() &&
+            (_wordlists.empty() ||
+             engine.get<bool>(name_related_probability));
+
         // Proceed to generate nickname based on name.
-        if (!name.empty() && engine.get<bool>(
-                                 name_related_probability))
+        if (use_name)
         {
             // Possible methods utilized to generate a nickname.
             // Purposefully adds redundancy to first and last name with any name
@@ -979,11 +1006,25 @@ class nng
             // Retrieves list of words.
             while (std::getline(tentative_file, file_line, delimiter))
             {
-                words_read.push_back(file_line);
+                // Strip trailing carriage return for cross-platform
+                // compatibility.
+                if (!file_line.empty() && file_line.back() == L'\r')
+                {
+                    file_line.pop_back();
+                }
+
+                // Skip empty lines (including blank trailing lines).
+                if (!file_line.empty())
+                {
+                    words_read.push_back(file_line);
+                }
             }
 
             // Index our container.
-            _wordlists.push_back(words_read);
+            if (!words_read.empty())
+            {
+                _wordlists.push_back(std::move(words_read));
+            }
         }
     }
 

tests/tests.cpp

@@ -150,6 +150,10 @@ struct nng_test_access
     {
         return g._wordlists;
     }
+    static std::vector<std::wstring> split_name(const std::wstring& s)
+    {
+        return dasmig::nng::split_name(s);
+    }
 };
 
 // ---------------------------------------------------------------------------
@@ -929,3 +933,95 @@ TEST_CASE("singleton still works after multi-instance changes",
     auto nick = g.get_nickname(L"Singleton Check");
     REQUIRE_FALSE(static_cast<std::wstring>(nick).empty());
 }
+
+// ===== Robustness / edge-case tests ========================================
+
+TEST_CASE("split_name filters consecutive spaces", "[nng][robustness]")
+{
+    // Double space should not produce empty parts.
+    auto parts = nng_test_access::split_name(L"John  Doe");
+    REQUIRE(parts.size() == 2);
+    REQUIRE(parts[0] == L"John");
+    REQUIRE(parts[1] == L"Doe");
+
+    // Leading/trailing spaces.
+    auto parts2 = nng_test_access::split_name(L" Jane ");
+    REQUIRE(parts2.size() == 1);
+    REQUIRE(parts2[0] == L"Jane");
+}
+
+TEST_CASE("initials handles consecutive spaces safely", "[nng][robustness]")
+{
+    // Should not crash — previously UB with empty parts.
+    auto result = nng_test_access::initials(L"John  Doe");
+    REQUIRE(result.size() == 2);
+}
+
+TEST_CASE("mix_two handles single-character name parts", "[nng][robustness]")
+{
+    // "Li A" has a 1-char part — previously UB (min > max in distribution).
+    for (int i = 0; i < 50; ++i)
+    {
+        auto nick = nng_test_access::mix_two(L"Li A");
+        REQUIRE_FALSE(nick.empty());
+    }
+}
+
+TEST_CASE("leetify does not stack-overflow on unmappable input",
+          "[nng][robustness]")
+{
+    // "M" (single consonant, no leet map entry) previously caused infinite
+    // recursion. Now capped at max depth.
+    dasmig::nng g;
+    g.load("resources");
+    g.seed(1);
+    for (int i = 0; i < 20; ++i)
+    {
+        auto nick = g.get_nickname(L"M");
+        REQUIRE_FALSE(static_cast<std::wstring>(nick).empty());
+    }
+}
+
+TEST_CASE("name-only generation works without wordlists", "[nng][robustness]")
+{
+    dasmig::nng g; // No load() — wordlists empty.
+
+    // Every call should succeed (previously 75% threw).
+    for (int i = 0; i < 50; ++i)
+    {
+        auto nick = g.get_nickname(L"John Smith");
+        REQUIRE_FALSE(static_cast<std::wstring>(nick).empty());
+    }
+}
+
+TEST_CASE("no-name no-wordlists still throws", "[nng][robustness]")
+{
+    dasmig::nng g;
+    REQUIRE_THROWS_AS(g.get_nickname(), std::invalid_argument);
+}
+
+TEST_CASE("64-bit seeds differing in upper bits produce different nicknames",
+          "[nng][robustness]")
+{
+    auto& g = gen();
+
+    // Two seeds identical in lower 32 bits but different in upper 32 bits.
+    constexpr std::uint64_t seed_lo = 42;
+    constexpr std::uint64_t seed_hi =
+        42 | (static_cast<std::uint64_t>(1) << 32U);
+
+    bool found_different = false;
+    for (int i = 0; i < 100; ++i)
+    {
+        auto a = static_cast<std::wstring>(
+            g.get_nickname(L"Bit Test", seed_lo + i));
+        auto b = static_cast<std::wstring>(
+            g.get_nickname(L"Bit Test", seed_hi + i));
+        if (a != b)
+        {
+            found_different = true;
+            break;
+        }
+    }
+    REQUIRE(found_different);
+}