Preserve mid-text spaces in legacy/MiniMessage round-trip

The legacy locale hack of stripping one space after a color code (so
auto-translators wouldn't glue "&c" onto "Hello") was being applied
unconditionally, including after &r and after mid-text color transitions.
This ate inter-segment spaces in round-tripped MiniMessage — e.g.
"<gray>Page </gray><yellow>[page]</yellow><gray> of </gray>..." rendered
as "Page 1of 4" because componentToLegacy emits "§7Page §e1§7 of §e4"
and legacyToMiniMessage then stripped the space after the mid-text §7.

Restrict the strip to boundary positions only: start of string, after
whitespace, or immediately after another legacy code. Also skip §r in
all cases (it's a format terminator). Applied in legacyToMiniMessage,
replaceLegacyCodesInline, and stripSpaceAfterColorCodes.

BentoBoxWorld/AOneBlock#495

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tastybento

src/main/java/world/bentobox/bentobox/util/Util.java

@@ -704,7 +704,14 @@ public static String translateColorCodes(@NonNull String textToColor) {
     @NonNull
     public static String stripSpaceAfterColorCodes(String textToStrip) {
         if (textToStrip == null) return "";
-        textToStrip = textToStrip.replaceAll("(\u00A7.)[\\s]", "$1");
+        // The legacy locale hack of writing "&c Hello" (with an intentional space so
+        // primitive auto-translators wouldn't glue "&c" onto "Hello") only applies when
+        // the §X code appears at a boundary — start of string, after whitespace, or
+        // immediately after another §X code. Mid-text codes (e.g. "Page §e1§7 of §e4"
+        // where §7 is preceded by a digit) must NOT strip the following space, because
+        // that space is content, not the hack. Also skip §r (reset) in all cases.
+        // See https://github.com/BentoBoxWorld/AOneBlock/issues/495.
+        textToStrip = textToStrip.replaceAll("(?<=^|\\s|\u00A7.)(\u00A7[^rR])\\s", "$1");
         return textToStrip;
     }
 
@@ -1059,16 +1066,28 @@ public static String legacyToMiniMessage(@NonNull String legacy) {
         StringBuilder result = new StringBuilder();
         List<String> openTags = new ArrayList<>();
         int i = 0;
+        // Tracks whether the previous character emitted was part of a legacy code we just
+        // consumed. Used for the boundary check on the legacy-space-stripping hack.
+        boolean justConsumedCode = false;
         while (i < text.length()) {
             if (i + 1 < text.length() && text.charAt(i) == '&') {
                 char code = Character.toLowerCase(text.charAt(i + 1));
                 String mmTag = LEGACY_TO_MM_MAP.get(code);
                 if (mmTag != null) {
+                    // Boundary check: the legacy locale hack only applies when the &X code
+                    // appears at a natural boundary — start of the string, after whitespace,
+                    // or immediately after another legacy code. Mid-text codes (e.g. "Page
+                    // §e1§7 of §e4" — the §7 is preceded by "1") must NOT strip the
+                    // following space, because that space is content, not the locale hack.
+                    // See https://github.com/BentoBoxWorld/AOneBlock/issues/495.
+                    boolean atBoundary = i == 0 || justConsumedCode
+                            || Character.isWhitespace(text.charAt(i - 1));
                     i += 2;
-                    // Strip space after color code (the locale hack)
-                    if (i < text.length() && text.charAt(i) == ' ') {
+                    // &r is a format terminator; any following space is always intentional.
+                    if (!"reset".equals(mmTag) && atBoundary && i < text.length() && text.charAt(i) == ' ') {
                         i++;
                     }
+                    justConsumedCode = true;
                     if ("reset".equals(mmTag)) {
                         // Close all open tags
                         for (int j = openTags.size() - 1; j >= 0; j--) {
@@ -1116,6 +1135,10 @@ public static String legacyToMiniMessage(@NonNull String legacy) {
             if (text.charAt(i) == '<' && text.substring(i).startsWith("<color:#")) {
                 int end = text.indexOf('>', i);
                 if (end != -1) {
+                    // Same boundary check as named &X codes — hex was originally &#RRGGBB
+                    // in the source string, so use the same rule for its space-strip.
+                    boolean atBoundaryHex = i == 0 || justConsumedCode
+                            || Character.isWhitespace(text.charAt(i - 1));
                     String colorTag = text.substring(i + 1, end);
                     // Close previous color tags, preserving decoration nesting
                     List<String> decorationsToReopen = new ArrayList<>();
@@ -1140,14 +1163,17 @@ public static String legacyToMiniMessage(@NonNull String legacy) {
                     result.append("<").append(colorTag).append(">");
                     openTags.add(colorTag);
                     i = end + 1;
-                    // Strip space after hex color code
-                    if (i < text.length() && text.charAt(i) == ' ') {
+                    // Strip space after hex color code only at a boundary.
+                    // See https://github.com/BentoBoxWorld/AOneBlock/issues/495.
+                    if (atBoundaryHex && i < text.length() && text.charAt(i) == ' ') {
                         i++;
                     }
+                    justConsumedCode = true;
                     continue;
                 }
             }
             result.append(text.charAt(i));
+            justConsumedCode = false;
             i++;
         }
         // Close any remaining open tags
@@ -1200,21 +1226,28 @@ public static String replaceLegacyCodesInline(@NonNull String text) {
         // Replace &X codes with MiniMessage tags (opening only, no closing)
         sb = new StringBuilder();
         int i = 0;
+        // See legacyToMiniMessage for the rationale behind the boundary check.
+        boolean justConsumedCode = false;
         while (i < text.length()) {
             if (i + 1 < text.length() && text.charAt(i) == '&') {
                 char code = Character.toLowerCase(text.charAt(i + 1));
                 String mmTag = LEGACY_TO_MM_MAP.get(code);
                 if (mmTag != null) {
+                    boolean atBoundary = i == 0 || justConsumedCode
+                            || Character.isWhitespace(text.charAt(i - 1));
                     sb.append("<").append(mmTag).append(">");
                     i += 2;
-                    // Strip space after color code (locale hack)
-                    if (i < text.length() && text.charAt(i) == ' ') {
+                    // Legacy locale hack — only strip at a boundary, and never after &r.
+                    // See https://github.com/BentoBoxWorld/AOneBlock/issues/495.
+                    if (!"reset".equals(mmTag) && atBoundary && i < text.length() && text.charAt(i) == ' ') {
                         i++;
                     }
+                    justConsumedCode = true;
                     continue;
                 }
             }
             sb.append(text.charAt(i));
+            justConsumedCode = false;
             i++;
         }
         return sb.toString();

src/test/java/world/bentobox/bentobox/util/LegacyToMiniMessageTest.java

@@ -187,4 +187,102 @@ void testBoldCarriesThroughHexColor() {
                 "Plain text should not contain literal </bold>: " + plainText);
         assertEquals("Bold Red", plainText);
     }
+
+    /**
+     * Regression for <a href="https://github.com/BentoBoxWorld/AOneBlock/issues/495">
+     * AOneBlock#495</a>: a MiniMessage locale string with a space between two colored
+     * segments must retain the space after going through the componentToLegacy →
+     * legacyToMiniMessage round-trip used by {@code User.sendMessage}.
+     */
+    @Test
+    void testInterSegmentSpacePreservedAcrossRoundTrip() {
+        String mm = "<red>Slow down.</red> <green>Click slower.</green>";
+        Component c = Util.parseMiniMessage(mm);
+        String legacy = Util.componentToLegacy(c);
+
+        // componentToLegacy emits the §r-space-§a pattern for the inter-segment whitespace
+        assertTrue(legacy.contains("\u00A7r "),
+                "expected reset-then-space in legacy form, got: " + legacy);
+
+        // Round-trip back through legacyToMiniMessage — the space must survive
+        String mmAgain = Util.legacyToMiniMessage(legacy);
+        assertFalse(mmAgain.contains("</red><green>"),
+                "space was eaten between segments: " + mmAgain);
+
+        Component c2 = Util.parseMiniMessage(mmAgain);
+        String plain = PlainTextComponentSerializer.plainText().serialize(c2);
+        assertEquals("Slow down. Click slower.", plain);
+    }
+
+    /**
+     * Backwards compat: the legacy locale hack of stripping one space after a
+     * color/decoration code must still work. Old locale files use {@code &c This is red}
+     * so primitive auto-translators wouldn't glue the code onto the word.
+     */
+    @Test
+    void testLegacyLocaleHackStillStripsSpaceAfterColorCode() {
+        String mm = Util.legacyToMiniMessage("&c This is red");
+        assertEquals("<red>This is red</red>", mm);
+    }
+
+    /**
+     * The locale hack must NOT apply to {@code &r}. &amp;r is a format terminator and any
+     * following space is intentional literal whitespace.
+     */
+    @Test
+    void testLegacyResetDoesNotStripFollowingSpace() {
+        String mm = Util.legacyToMiniMessage("&cHello&r world");
+        String plain = PlainTextComponentSerializer.plainText().serialize(Util.parseMiniMessage(mm));
+        assertEquals("Hello world", plain);
+    }
+
+    /**
+     * Regression for <a href="https://github.com/BentoBoxWorld/AOneBlock/issues/495">
+     * AOneBlock#495</a>: a "Page [page] of [total]" template with alternating colors.
+     * The round-trip emits {@code §7Page §e1§7 of §e4}. The second {@code §7} is
+     * preceded by a digit, not by a boundary, so the space after it is content and
+     * must be preserved.
+     */
+    @Test
+    void testMidTextColorCodeDoesNotStripContentSpace() {
+        String mm = "<gray>Page </gray><yellow>1</yellow><gray> of </gray><yellow>4</yellow>";
+        // Forward: MiniMessage → componentToLegacy
+        Component c = Util.parseMiniMessage(mm);
+        String legacy = Util.componentToLegacy(c);
+        // Round-trip: legacy → Component
+        Component finalComp = Util.parseMiniMessageOrLegacy(legacy);
+        String plain = PlainTextComponentSerializer.plainText().serialize(finalComp);
+        assertEquals("Page 1 of 4", plain);
+    }
+
+    /**
+     * Same scenario exercised through {@code replaceLegacyCodesInline} (the mixed-content
+     * path used when MiniMessage templates contain legacy-coded variable substitutions).
+     */
+    @Test
+    void testMidTextCodeInReplaceLegacyCodesInlinePreservesSpace() {
+        // Mixed content: MiniMessage tags with legacy codes embedded (e.g. from a variable).
+        String mixed = "<gray>Page </gray>&e1&7 of &e4";
+        String result = Util.replaceLegacyCodesInline(mixed);
+        // The &7 here is preceded by "1" (mid-text), so the space after it must survive.
+        String plain = PlainTextComponentSerializer.plainText().serialize(Util.parseMiniMessage(result));
+        assertEquals("Page 1 of 4", plain);
+    }
+
+    /**
+     * {@code stripSpaceAfterColorCodes} (used by the deprecated {@code translateColorCodes}
+     * pure-legacy path) must use the same boundary rule.
+     */
+    @Test
+    @SuppressWarnings("deprecation")
+    void testStripSpaceAfterColorCodesRespectsBoundary() {
+        // Boundary cases: strip applies
+        assertEquals("\u00A7cHello", Util.stripSpaceAfterColorCodes("\u00A7c Hello"));
+        assertEquals("\u00A7l\u00A7cBold", Util.stripSpaceAfterColorCodes("\u00A7l\u00A7c Bold"));
+        // Mid-text: must NOT strip
+        assertEquals("\u00A77Page \u00A7e1\u00A77 of \u00A7e4",
+                Util.stripSpaceAfterColorCodes("\u00A77Page \u00A7e1\u00A77 of \u00A7e4"));
+        // Reset must NOT strip
+        assertEquals("\u00A7r world", Util.stripSpaceAfterColorCodes("\u00A7r world"));
+    }
 }