Java Text Blocks — Invisible Whitespace Broke Payment API

public class OldStyleStrings {

    public static void main(String[] args) {

        // The OLD way: a JSON object embedded as a traditional string.
        // Notice how unreadable this is — escaped quotes everywhere,
        // plus-signs to join lines, and \n to fake line breaks.
        // A reviewer has to mentally decode this before they can evaluate
        // whether the JSON structure is actually correct.
        String customerJson = "{\n" +
                "  \"name\": \"Alice\",\n" +
                "  \"age\": 30,\n" +
                "  \"city\": \"Dublin\"\n" +
                "}";

        // The same SQL query written the old way.
        // Good luck spotting a typo in here during a code review.
        // More importantly — can you see the bug? Look closely.
        String findActiveUsers =
                "SELECT user_id, email, created_at " +
                "FROM users " +
                "WHERE status = 'active' " +
                "AND created_at > '2024-01-01' " +
                "ORDER BY created_at DESC;";

        System.out.println("--- JSON Output ---");
        System.out.println(customerJson);

        System.out.println("\n--- SQL Output ---");
        System.out.println(findActiveUsers);
    }
}

public class TextBlockBasics {

    public static void main(String[] args) {

        // TEXT BLOCK SYNTAX:
        // 1. Opening delimiter: three double-quotes then IMMEDIATELY a newline.
        // 2. Your content, written exactly as you want it to look.
        // 3. Closing delimiter: three double-quotes.
        //
        // That's it. No other magic required.

        // Example 1: A JSON object — looks like real JSON, not a string puzzle.
        // Notice: no escaped quotes around "SKU-9921" or "Mechanical Keyboard".
        // You just write them. The text block handles it.
        String productJson = """
                {
                  "productId": "SKU-9921",
                  "name": "Mechanical Keyboard",
                  "price": 129.99,
                  "inStock": true
                }
                """;

        // Example 2: An HTML snippet — double quotes in the class attribute
        // and href values need zero escaping. Write it like you'd write it
        // in an actual HTML file.
        String welcomeHtml = """
                <div class="welcome-banner">
                    <h1>Welcome back!</h1>
                    <p>Your session started at 09:00 AM.</p>
                </div>
                """;

        // Example 3: A multi-line SQL query — readable like actual SQL.
        // The JOIN, WHERE, GROUP BY, and ORDER BY each sit on their own lines
        // with natural indentation. This is exactly what goes to the database.
        String topSellerQuery = """
                SELECT p.name, SUM(o.quantity) AS total_sold
                FROM products p
                JOIN order_items o ON p.id = o.product_id
                WHERE p.category = 'electronics'
                GROUP BY p.name
                ORDER BY total_sold DESC
                LIMIT 10;
                """;

        System.out.println("=== JSON ===");
        System.out.println(productJson);

        System.out.println("=== HTML ===");
        System.out.println(welcomeHtml);

        System.out.println("=== SQL ===");
        System.out.println(topSellerQuery);
    }
}

public class IndentationStripping {

    public static void main(String[] args) {

        // SCENARIO A: Closing delimiter on its own line, aligned with content.
        // All content lines have 16 spaces of leading indentation.
        // The closing """ also sits at 16 spaces.
        // Java finds the common prefix: 16 spaces.
        // Strips 16 spaces from every line.
        // The 2 extra spaces before 'City:' are BEYOND the common prefix,
        // so they're preserved — that's intentional relative indentation.
        String addressBlock = """
                Street: 42 Elm Road
                  City: Springfield
                Country: Ireland
                """;

        System.out.println("SCENARIO A — standard stripping:");
        System.out.println(addressBlock);
        // Output has zero leading spaces on 'Street' and 'Country'.
        // 'City' retains its 2-space relative indent — correctly.

        // SCENARIO B: Closing delimiter at column 0.
        // Java's minimum prefix is now 0 — there's a line (the closing delimiter)
        // with no leading whitespace at all.
        // Result: NOTHING is stripped. Every content line keeps its 16 spaces.
        // This is almost never what you want — shown here so you recognize it.
        String withLeadingSpaces = """
                Line one has 16 leading spaces in the output
                Line two also has 16 leading spaces in the output
""";
        // Closing """ is at column 0 — all source indentation is preserved.

        System.out.println("SCENARIO B — closing delimiter at column 0:");
        // The pipe characters bracket the line and make the leading spaces visible.
        System.out.println("|" + withLeadingSpaces.lines().findFirst().orElse("") + "|");

        // SCENARIO C: Using indent() to ADD indentation programmatically.
        // indent(n) prepends n spaces to every line and guarantees a trailing newline.
        // Useful when you want a clean text block for one context but need
        // it indented for another (e.g., nesting content inside a larger template).
        String codeSnippet = """
                if (loggedIn) {
                    showDashboard();
                }
                """;

        System.out.println("SCENARIO C — adding 4-space indent with indent():");
        System.out.print(codeSnippet.indent(4));
        // Every line now has 4 additional leading spaces.
        // indent() always ensures a trailing newline is present.
    }
}

public class TextBlockMethods {

    public static void main(String[] args) {

        // --- formatted(): inline variable substitution on a text block ---
        // formatted() is String.format() as an instance method.
        // Call it directly on the text block — the template and its values
        // stay visually adjacent. Much cleaner than wrapping the whole block
        // in String.format("""...""", value1, value2, ...).
        String userName = "Maria";
        int orderCount = 3;
        double totalAmount = 74.50;

        String orderSummaryEmail = """
                Hi %s,

                Thanks for your order! Here's a quick summary:
                  Orders placed : %d
                  Total charged : $%.2f

                We'll email your receipt shortly.
                """.formatted(userName, orderCount, totalAmount);

        System.out.println("=== Order Confirmation Email ===");
        System.out.println(orderSummaryEmail);

        // --- stripIndent(): same algorithm as text blocks, at runtime ---
        // Useful when indented text comes from a file, database, or API
        // response — anywhere the compiler can't process it at build time.
        String rawTextFromFile =
                "    SELECT id\n" +
                "    FROM sessions\n" +
                "    WHERE active = true;\n";
        // This string has 4 spaces of leading indentation on every line.
        // stripIndent() finds the common prefix (4 spaces) and removes it.

        String cleanedQuery = rawTextFromFile.stripIndent();
        System.out.println("=== stripIndent() result ===");
        System.out.println(cleanedQuery);
        // Output: clean SQL with zero leading spaces.

        // --- translateEscapes(): converts \t and \n from literal to real ---
        // The raw string below has backslash-t and backslash-n as two-character
        // sequences. They are NOT tab characters or newline characters yet.
        // translateEscapes() converts them to actual control characters.
        String rawEscapes = "Column1\\tColumn2\\tColumn3\\nRow1\\tRow2\\tRow3";

        String processedTable = rawEscapes.translateEscapes();
        System.out.println("=== translateEscapes() result ===");
        System.out.println(processedTable);
        // Output: tab-separated columns with an actual newline between header and row.

        // --- Text blocks are just String objects: prove it ---
        // A text block with a trailing newline (closing """ on its own line)
        // is equal to the same regular string with \n appended.
        String textBlockGreeting = """
                Hello, World!
                """;
        String regularGreeting = "Hello, World!\n";

        boolean contentMatches = textBlockGreeting.equals(regularGreeting);
        System.out.println("\nText block equals regular String: " + contentMatches);
        // Prints: true. Same type, same content, same bytecode.
    }
}

import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;

public class TextBlockTestPatterns {

    // Production pattern 1: text blocks make test assertions readable and auditable.
    // A reviewer can compare this expected JSON against the actual API contract
    // by eye — that was not possible with escaped concatenated strings.
    // Notice: if UserService.toJson() ever changes the field order or adds a field,
    // this test will fail and the diff will show exactly which line changed.
    @Test
    void io_thecodeforge_shouldReturnCorrectUserJson() {
        String expected = """
                {
                  "id": 42,
                  "name": "Alice Byrne",
                  "email": "alice@thecodeforge.io",
                  "roles": ["admin", "editor"],
                  "active": true
                }
                """;

        String actual = UserService.toJson(
                new User(42, "Alice Byrne", "alice@thecodeforge.io",
                         List.of("admin", "editor"), true));

        // .strip() on both sides eliminates trailing newline false failures.
        // The text block's closing delimiter on its own line adds \n;
        // the system under test may or may not. Strip both and compare content.
        assertEquals(expected.strip(), actual.strip());
    }

    // Production pattern 2: text block as a code generation template.
    // The structure of the generated Java record is readable right here in source.
    // You don't need to run the generator to verify the output format.
    String io_thecodeforge_generateRecord(String className, String... fields) {
        return """
                package io.thecodeforge.generated;

                public record %s(
                        %s
                ) {}
                """.formatted(className, String.join(",\n        ", fields));
    }

    @Test
    void io_thecodeforge_shouldGenerateValidRecordSource() {
        String source = io_thecodeforge_generateRecord("PaymentEvent",
                "String transactionId", "String amount", "String currency");

        // Structural assertions: verify the generated code contains
        // what it must, without being brittle about exact whitespace.
        assertTrue(source.contains("public record PaymentEvent"),
                "Generated source must declare the record type");
        assertTrue(source.contains("String transactionId"),
                "Generated source must include the transactionId field");
        assertTrue(source.contains("package io.thecodeforge.generated"),
                "Generated source must have the correct package declaration");
    }
}