Return the whole key when a section key contains the separator

A child section handed out by getKeysSections carries its key in the escaped path form, but getSectionKey and getParentSection split on a raw lastIndexOf of the separator. A key that legitimately holds the separator (a server id like "eu.west") then came back as its trailing half, and the parent was cut inside the escape, leaving a dangling backslash.

Route both through the dotted-path grammar (leaf/parent), which already splits on the last UNescaped separator and unescapes the key. Resolution was never affected; only these two decomposition accessors were.

Author: EverNife

src/main/java/br/com/finalcraft/everyconfig/config/section/ConfigSection.java

@@ -5,6 +5,7 @@
 import br.com.finalcraft.everyconfig.config.Config;
 import br.com.finalcraft.everyconfig.config.MigrationResult;
 import br.com.finalcraft.everyconfig.core.comment.CommentType;
+import br.com.finalcraft.everyconfig.core.tree.DPath;
 import com.fasterxml.jackson.databind.JsonNode;
 
 import java.util.List;
@@ -42,17 +43,17 @@ public String getPath() {
         return path;
     }
 
-    /** The leaf key of this section's path (its last segment). */
+    /**
+     * The leaf key of this section's path, as the LITERAL key: a separator inside it was escaped on the
+     * way in, so it is unescaped on the way out and the key comes back whole.
+     */
     public String getSectionKey() {
-        final char sep = config.pathSeparator();
-        final int i = path.lastIndexOf(sep);
-        return i < 0 ? path : path.substring(i + 1);
+        return DPath.leaf(path);
     }
 
+    /** This section's parent, cutting at the last UNescaped separator so an escaped one stays a key. */
     public ConfigSection getParentSection() {
-        final char sep = config.pathSeparator();
-        final int i = path.lastIndexOf(sep);
-        return new ConfigSection(config, i < 0 ? "" : path.substring(0, i));
+        return new ConfigSection(config, DPath.parent(path));
     }
 
     /** Absolute path for a sub-path within this section. */

src/test/java/br/com/finalcraft/everyconfig/config/section/ConfigSectionPathGrammarTest.java

@@ -0,0 +1,77 @@
+package br.com.finalcraft.everyconfig.config.section;
+
+import br.com.finalcraft.everyconfig.config.Config;
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * A key that legitimately holds the path separator ({@code "eu.west"}) travels the path grammar escaped
+ * ({@code servers.eu\.west}). These pin the round-trip: whoever hands out a child section must be able to
+ * ask it back for its own key and its parent, and get the literal key and the real parent - not the two
+ * halves the escape was there to prevent splitting.
+ */
+class ConfigSectionPathGrammarTest {
+
+    /** The escaped path form of the single key {@code "eu.west"} nested under {@code "servers"}. */
+    private static final String ESCAPED_PATH = "servers.eu\\.west";
+
+    private static Config configWithADottedKey() {
+        final Config cfg = Config.inMemory();
+        cfg.setValue(ESCAPED_PATH + ".port", 25565);
+        return cfg;
+    }
+
+    private static ConfigSection onlyChildOfServers(final Config cfg) {
+        final Set<ConfigSection> children = cfg.getKeysSections("servers");
+        assertEquals(1, children.size(), "the dotted key must be ONE child, not two");
+        return children.iterator().next();
+    }
+
+    @Test
+    void aChildHandedOutByGetKeysSectionsKnowsItsOwnLiteralKey() {
+        final ConfigSection child = onlyChildOfServers(configWithADottedKey());
+
+        assertEquals(ESCAPED_PATH, child.getPath(), "the path stays in escaped form");
+        assertEquals("eu.west", child.getSectionKey(),
+                "the key must come back whole - splitting it is what the escape prevents");
+    }
+
+    @Test
+    void theParentOfADottedKeyIsNotCutInsideTheEscape() {
+        final ConfigSection child = onlyChildOfServers(configWithADottedKey());
+
+        assertEquals("servers", child.getParentSection().getPath(),
+                "cutting at the escaped separator would leave a dangling backslash");
+    }
+
+    @Test
+    void aChildKeyIsUsableToReadBackThroughItsOwnSection() {
+        final ConfigSection child = onlyChildOfServers(configWithADottedKey());
+
+        assertEquals(25565, child.getInt("port"), "the section must resolve against the whole key");
+    }
+
+    @Test
+    void anOrdinaryKeyIsUnaffected() {
+        final Config cfg = Config.inMemory();
+        cfg.setValue("servers.lobby.port", 25565);
+
+        final ConfigSection child = onlyChildOfServers(cfg);
+
+        assertEquals("lobby", child.getSectionKey());
+        assertEquals("servers", child.getParentSection().getPath());
+    }
+
+    @Test
+    void aRootSectionHasNoKeyAndNoParentPath() {
+        final Config cfg = Config.inMemory();
+        cfg.setValue("top", 1);
+
+        final ConfigSection top = cfg.getConfigSection("top");
+        assertEquals("top", top.getSectionKey());
+        assertEquals("", top.getParentSection().getPath());
+    }
+}