From 135e9792f532514e84d96e9f9a2eae735254f076 Mon Sep 17 00:00:00 2001
From: LauH1987 <Lau.H1987@gmail.com>
Date: Mon, 11 May 2026 10:42:52 +0200
Subject: [PATCH 1/2] Fixing nested struct prefix

---
 src/ser.rs | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 67 insertions(+), 1 deletion(-)

diff --git a/src/ser.rs b/src/ser.rs
index 6f89938..78030ed 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -576,11 +576,13 @@ where
         return Err(Error::UnsupportedStructureInSeq);
     }
 
+    let saved_prefix = ser.prefix_before.clone();
+
     ser.output += "=";
     value.serialize(&mut **ser)?;
     ser.output += "\n";
 
-    ser.prefix = ser.prefix_before.clone();
+    ser.prefix = saved_prefix;
     Ok(())
 }
 
@@ -635,6 +637,70 @@ mod tests {
         assert_eq!("A=1\nB_C=2", output);
     }
 
+    #[test]
+    fn serialize_to_string_struct_field_after_nested() {
+        #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+        struct Inner {
+            x: u8,
+        }
+
+        #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+        struct Outer {
+            a: u8,
+            inner: Inner,
+            b: u8,
+        }
+
+        let env = Outer {
+            a: 1,
+            inner: Inner { x: 2 },
+            b: 3,
+        };
+
+        let output = to_string(&env).expect("Failed to serialize to string");
+
+        assert_eq!("A=1\nINNER_X=2\nB=3", output);
+    }
+
+    #[test]
+    fn serialize_to_string_deeply_nested_struct() {
+        #[derive(Debug, PartialEq, serde::Serialize)]
+        struct Level2 {
+            z: u8,
+        }
+
+        #[derive(Debug, PartialEq, serde::Serialize)]
+        struct Level1 {
+            y: u8,
+            level2: Level2,
+            y2: u8,
+        }
+
+        #[derive(Debug, PartialEq, serde::Serialize)]
+        struct Root {
+            a: u8,
+            level1: Level1,
+            b: u8,
+        }
+
+        let env = Root {
+            a: 1,
+            level1: Level1 {
+                y: 2,
+                level2: Level2 { z: 3 },
+                y2: 4,
+            },
+            b: 5,
+        };
+
+        let output = to_string(&env).expect("Failed to serialize to string");
+
+        assert_eq!(
+            "A=1\nLEVEL1_Y=2\nLEVEL1_LEVEL2_Z=3\nLEVEL1_Y2=4\nB=5",
+            output
+        );
+    }
+
     #[test]
     fn serialize_to_string_sequence() {
         //* Given

From a649a4c15f033f518f86ca9d0e8f7ebb32723d21 Mon Sep 17 00:00:00 2001
From: Luca Goslar <47827429+lucagoslar@users.noreply.github.com>
Date: Fri, 15 May 2026 20:48:13 +0200
Subject: [PATCH 2/2] refactor: normalize variable names and merge tests

---
 src/ser.rs | 83 ++++++++++--------------------------------------------
 1 file changed, 15 insertions(+), 68 deletions(-)

diff --git a/src/ser.rs b/src/ser.rs
index 78030ed..f02abff 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -576,13 +576,13 @@ where
         return Err(Error::UnsupportedStructureInSeq);
     }
 
-    let saved_prefix = ser.prefix_before.clone();
+    let prefix_before = ser.prefix_before.clone();
 
     ser.output += "=";
     value.serialize(&mut **ser)?;
     ser.output += "\n";
 
-    ser.prefix = saved_prefix;
+    ser.prefix = prefix_before;
     Ok(())
 }
 
@@ -614,91 +614,38 @@ mod tests {
     #[test]
     fn serialize_to_string_struct() {
         //* Given
+        #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+        struct StructTestNestedNested {
+            e: u8,
+        }
+
         #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
         struct StructTestNested {
             c: u8,
+            d: StructTestNestedNested,
         }
 
         #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
         struct StructTest {
             a: u8,
             b: StructTestNested,
+            f: u8,
         }
 
         let env = StructTest {
             a: 1,
-            b: StructTestNested { c: 2 },
+            b: StructTestNested {
+                c: 2,
+                d: StructTestNestedNested { e: 3 },
+            },
+            f: 4,
         };
 
         //* When
         let output = to_string(&env).expect("Failed to serialize to string");
 
         //* Then
-        assert_eq!("A=1\nB_C=2", output);
-    }
-
-    #[test]
-    fn serialize_to_string_struct_field_after_nested() {
-        #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-        struct Inner {
-            x: u8,
-        }
-
-        #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-        struct Outer {
-            a: u8,
-            inner: Inner,
-            b: u8,
-        }
-
-        let env = Outer {
-            a: 1,
-            inner: Inner { x: 2 },
-            b: 3,
-        };
-
-        let output = to_string(&env).expect("Failed to serialize to string");
-
-        assert_eq!("A=1\nINNER_X=2\nB=3", output);
-    }
-
-    #[test]
-    fn serialize_to_string_deeply_nested_struct() {
-        #[derive(Debug, PartialEq, serde::Serialize)]
-        struct Level2 {
-            z: u8,
-        }
-
-        #[derive(Debug, PartialEq, serde::Serialize)]
-        struct Level1 {
-            y: u8,
-            level2: Level2,
-            y2: u8,
-        }
-
-        #[derive(Debug, PartialEq, serde::Serialize)]
-        struct Root {
-            a: u8,
-            level1: Level1,
-            b: u8,
-        }
-
-        let env = Root {
-            a: 1,
-            level1: Level1 {
-                y: 2,
-                level2: Level2 { z: 3 },
-                y2: 4,
-            },
-            b: 5,
-        };
-
-        let output = to_string(&env).expect("Failed to serialize to string");
-
-        assert_eq!(
-            "A=1\nLEVEL1_Y=2\nLEVEL1_LEVEL2_Z=3\nLEVEL1_Y2=4\nB=5",
-            output
-        );
+        assert_eq!("A=1\nB_C=2\nB_D_E=3\nF=4", output);
     }
 
     #[test]