fix(toml): swap uiri/toml encoder for tomli_w (issue #439 residual)

The uiri/toml encoder raises IndexError on strings containing certain
characters (notably real control characters like chr(27)/ANSI escape).
Issue #439 identified this class of bugs and proposed switching to
tomli-w. Decode was migrated to stdlib tomllib on 3.11+ previously,
but encode still routed through toml.dumps and still crashed.

Reproducer on main:

    >>> benedict({"color": "\033[31m"}).to_toml()
    IndexError: list index out of range

Change: TOMLSerializer.encode() now calls tomli_w.dumps(). Decode path
untouched (tomllib on 3.11+, toml on 3.10). toml stays in the [toml]
extra guarded by python_version < '3.11' for the 3.10 decode fallback;
tomli-w is added unconditionally for encode.

Regression tests cover:
- ANSI control character (chr(27)) encode + round-trip — was crashing
- Issue #439's literal-backslash examples — guard against regression
- Round-trip on 7 tricky values (control chars, tabs, unicode, quotes)
- Nested dict with embedded control chars
- Direct serializer encode/decode path

tests/serializers/test_toml_serializer.py replaces the prior TODO
stubs with 5 real tests. test_io_dict_toml's "extra not installed"
test patches tomli_w_installed (the encode dependency) instead of
toml_installed.

API note: tomli_w.dumps kwargs differ from toml.dumps (no `encoder=`
param; gains `multiline_strings` and `indent`). Callers of
`.to_toml(**kwargs)` passing uiri-specific kwargs will hit TypeError
and should migrate to tomli-w's kwarg surface.

Full suite: 800 tests pass (1 pre-existing skip).

Fixes the encode-side failure mode documented in #439.

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

Author: ricaskew

benedict/serializers/toml.py

@@ -5,6 +5,13 @@
 except ModuleNotFoundError:
     toml_installed = False
 
+try:
+    import tomli_w
+
+    tomli_w_installed = True
+except ModuleNotFoundError:
+    tomli_w_installed = False
+
 try:
     # python >= 3.11
     import tomllib
@@ -40,6 +47,6 @@ def decode(self, s: str, **kwargs: Any) -> Any:
         return data
 
     def encode(self, d: Any, **kwargs: Any) -> str:
-        require_toml(installed=toml_installed)
-        data = toml.dumps(dict(d), **kwargs)
+        require_toml(installed=tomli_w_installed)
+        data = tomli_w.dumps(dict(d), **kwargs)
         return data

pyproject.toml

@@ -138,7 +138,8 @@ s3 = [
     "boto3 >= 1.24.89, < 2.0.0",
 ]
 toml = [
-    "toml >= 0.10.2, < 1.0.0",
+    "toml >= 0.10.2, < 1.0.0; python_version < '3.11'",
+    "tomli-w >= 1.0.0, < 2.0.0",
 ]
 xls = [
     "openpyxl >= 3.0.0, < 4.0.0",

requirements.txt

@@ -12,6 +12,7 @@ python-slugify == 8.0.4
 pyyaml == 6.0.3
 requests == 2.33.1
 toml == 0.10.2
+tomli-w == 1.2.0
 typing_extensions >= 4.14.1
 urllib3 >= 2.6.3
 useful-types == 0.2.1

tests/dicts/io/test_io_dict_toml.py

@@ -184,7 +184,7 @@ def test_to_toml_file(self) -> None:
         self.assertFileExists(filepath)
         self.assertEqual(d, IODict.from_toml(filepath))
 
-    @patch("benedict.serializers.toml.toml_installed", False)
+    @patch("benedict.serializers.toml.tomli_w_installed", False)
     def test_to_toml_with_extra_not_installed(self) -> None:
         d = IODict(
             {

tests/serializers/test_toml_serializer.py

@@ -1,17 +1,82 @@
 import unittest
 
-# from benedict.serializers import TOMLSerializer
+from benedict import benedict
+from benedict.dicts.io import IODict
+from benedict.serializers import TOMLSerializer
 
 
 class toml_serializer_test_case(unittest.TestCase):
     """
     This class describes a toml serializer test case.
+
+    Regression coverage for issue #439 — the uiri/toml encoder crashes
+    on certain strings. These tests pin the encode path to a library
+    that handles them correctly and guard against regression.
     """
 
-    def test_decode_toml(self) -> None:
-        # TODO
-        pass
+    def test_encode_ansi_control_character(self):
+        """Scenario 1 — falsification clause #1.
+
+        `benedict({"color": "\033[31m"}).to_toml()` must not raise. On
+        baseline (uiri/toml) this raises IndexError in the encoder.
+        """
+        payload = {"color": "\033[31m"}
+        encoded = benedict(payload).to_toml()
+        self.assertIsInstance(encoded, str)
+        self.assertGreater(len(encoded), 0)
+        # Round-trip: decoded value must equal the original string.
+        decoded = IODict.from_toml(encoded)
+        self.assertEqual(decoded["color"], "\033[31m")
+
+    def test_encode_issue_439_literal_examples(self):
+        """Scenario 2 — regression guard for issue #439's cited examples.
+
+        These pass on baseline (literal backslashes, not control chars).
+        Kept so the encoder swap does not silently regress them.
+        """
+        payload = {
+            "reset": "\\033\\[00;00m",
+            "lightblue": "\\033\\[01;30m",
+        }
+        encoded = benedict(payload).to_toml()
+        self.assertIsInstance(encoded, str)
+        decoded = IODict.from_toml(encoded)
+        self.assertEqual(decoded["reset"], "\\033\\[00;00m")
+        self.assertEqual(decoded["lightblue"], "\\033\\[01;30m")
+
+    def test_roundtrip_control_chars_and_unicode(self):
+        """Scenario 4 — round-trip integrity across tricky values."""
+        payload = {
+            "ansi_red": "\033[31m",
+            "ansi_reset": "\033[0m",
+            "bell": "\x07",
+            "tab_and_newline": "a\tb\nc",
+            "unicode_emoji": "benedict 🎩",
+            "backslash": "path\\to\\file",
+            "quotes": 'he said "hi"',
+        }
+        encoded = benedict(payload).to_toml()
+        decoded = IODict.from_toml(encoded)
+        for key, value in payload.items():
+            self.assertEqual(decoded[key], value, f"round-trip mismatch for {key!r}")
+
+    def test_encode_nested_dict(self):
+        """Structural coverage — nested dicts still encode correctly."""
+        payload = {
+            "section": {
+                "key": "value",
+                "control": "\033[31m",
+            }
+        }
+        encoded = benedict(payload).to_toml()
+        decoded = IODict.from_toml(encoded)
+        self.assertEqual(decoded["section"]["key"], "value")
+        self.assertEqual(decoded["section"]["control"], "\033[31m")
 
-    def test_encode_toml(self) -> None:
-        # TODO
-        pass
+    def test_serializer_decode_roundtrip(self):
+        """Direct serializer-level round-trip (bypasses IODict convenience layer)."""
+        serializer = TOMLSerializer()
+        payload = {"color": "\033[31m", "count": 42}
+        encoded = serializer.encode(payload)
+        decoded = serializer.decode(encoded)
+        self.assertEqual(decoded, payload)