Fixes #1200: change default for "Escape slash" to true for 3.0 (#1201)

Author: cowtowncoder

release-notes/VERSION

@@ -40,6 +40,7 @@ JSON library.
 #793: Rename "com.fasterxml.jackson" -> "tools.jackson"
 #1090: Remove `BufferRecyclers.SYSTEM_PROPERTY_TRACK_REUSABLE_BUFFERS`
 #1125: Remove `TokenStreamFactory.Feature.USE_THREAD_LOCAL_FOR_BUFFER_RECYCLING`
+#1200: Change `JsonWriteFeature.ESCAPE_FORWARD_SLASHES` default to `true` for 3.0
 - Rename `JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT` as `AUTO_CLOSE_CONTENT`
 - Add `TreeCodec.nullNode()`, `TreeNode.isNull()` methods
 - Change the way `JsonLocation.NA` is included in exception messages

src/main/java/tools/jackson/core/io/CharTypes.java

@@ -153,7 +153,7 @@ public final class CharTypes
      * Lookup table used for determining which output characters in
      * 7-bit ASCII range need to be quoted.
      */
-    protected final static int[] sOutputEscapes128;
+    protected final static int[] sOutputEscapes128NoSlash;
     static {
         int[] table = new int[128];
         // Control chars need generic escape sequence
@@ -170,16 +170,16 @@ public final class CharTypes
         table[0x0C] = 'f';
         table[0x0A] = 'n';
         table[0x0D] = 'r';
-        sOutputEscapes128 = table;
+        sOutputEscapes128NoSlash = table;
     }
 
     /**
-     * Lookup table same as {@link #sOutputEscapes128} except that
+     * Lookup table same as {@link #sOutputEscapes128NoSlash} except that
      * forward slash ('/') is also escaped
      */
     protected final static int[] sOutputEscapes128WithSlash;
     static {
-        sOutputEscapes128WithSlash = Arrays.copyOf(sOutputEscapes128, sOutputEscapes128.length);
+        sOutputEscapes128WithSlash = Arrays.copyOf(sOutputEscapes128NoSlash, sOutputEscapes128NoSlash.length);
         sOutputEscapes128WithSlash['/'] = '/';
     }
 
@@ -217,25 +217,13 @@ public final class CharTypes
      * Value of 0 means "no escaping"; other positive values that value is character
      * to use after backslash; and negative values that generic (backslash - u)
      * escaping is to be used.
+     *<p>
+     * NOTE: as of Jackson 3.0, forward slash ({@code "/"}) is escaped by default.
      *
      * @return 128-entry {@code int[]} that contains escape definitions
      */
-    public static int[] get7BitOutputEscapes() { return sOutputEscapes128; }
-
-    /**
-     * Alternative to {@link #get7BitOutputEscapes()} when a non-standard quote character
-     * is used.
-     *
-     * @param quoteChar Character used for quoting textual values and property names;
-     *    usually double-quote but sometimes changed to single-quote (apostrophe)
-     *
-     * @return 128-entry {@code int[]} that contains escape definitions
-     */
-    public static int[] get7BitOutputEscapes(int quoteChar) {
-        if (quoteChar == '"') {
-            return sOutputEscapes128;
-        }
-        return AltEscapes.instance.escapesFor(quoteChar);
+    public static int[] get7BitOutputEscapes() {
+        return get7BitOutputEscapes('"', true);
     }
 
     /**
@@ -244,7 +232,8 @@ public static int[] get7BitOutputEscapes(int quoteChar) {
      *
      * @param quoteChar Character used for quoting textual values and property names;
      *    usually double-quote but sometimes changed to single-quote (apostrophe)
-     * @param escapeSlash
+     * @param escapeSlash Whether forward slash ({@code "/"}) is escaped by default
+     *    or not.
      *
      * @return 128-entry {@code int[]} that contains escape definitions
      *
@@ -255,9 +244,9 @@ public static int[] get7BitOutputEscapes(int quoteChar, boolean escapeSlash) {
             if (escapeSlash) {
                 return sOutputEscapes128WithSlash;
             }
-            return sOutputEscapes128;
+            return sOutputEscapes128NoSlash;
         }
-        return AltEscapes.instance.escapesFor(quoteChar, escapeSlash);
+        return AltQuoteEscapes.instance.altEscapesFor(quoteChar, escapeSlash);
     }
 
     public static int charToHex(int ch)
@@ -283,7 +272,7 @@ public static char hexToChar(int ch)
      * @param content Unescaped String value to append with escaping applied
      */
     public static void appendQuoted(StringBuilder sb, String content) {
-        final int[] escCodes = sOutputEscapes128;
+        final int[] escCodes = sOutputEscapes128WithSlash;
         final int escLen = escCodes.length;
         for (int i = 0, len = content.length(); i < len; ++i) {
             char c = content.charAt(i);
@@ -327,38 +316,43 @@ public static byte[] copyHexBytes(boolean uppercase) {
      * table, used for escaping content that uses non-standard quote
      * character (usually apostrophe).
      */
-    private static class AltEscapes {
-        public final static AltEscapes instance = new AltEscapes();
+    private static class AltQuoteEscapes {
+        public final static AltQuoteEscapes instance = new AltQuoteEscapes();
 
-        private int[][] _altEscapes = new int[128][];
+        private int[][] _altEscapesNoSlash = new int[128][];
 
         // @since 2.17
         private int[][] _altEscapesWithSlash = new int[128][];
 
-        public int[] escapesFor(int quoteChar) {
-            int[] esc = _altEscapes[quoteChar];
+        public int[] altEscapesFor(int quoteChar, boolean escapeSlash)
+        {
+            int[] esc = escapeSlash
+                    ? _altEscapesWithSlash[quoteChar]
+                    : _altEscapesNoSlash[quoteChar];
             if (esc == null) {
-                esc = Arrays.copyOf(sOutputEscapes128, 128);
+                esc = escapeSlash
+                        ? sOutputEscapes128WithSlash
+                        : sOutputEscapes128NoSlash;
+                esc = Arrays.copyOf(esc, esc.length);
                 // Only add escape setting if character does not already have it
                 if (esc[quoteChar] == 0) {
-                    esc[quoteChar] = CharacterEscapes.ESCAPE_STANDARD;
+                    // And try to use "natural" escape for apos
+                    int quoteStyle;
+                    switch (quoteChar) {
+                    case '\'':
+                    case '"':
+                        quoteStyle = quoteChar;
+                        break;
+                    default:
+                        quoteStyle = CharacterEscapes.ESCAPE_STANDARD;
+                    }
+                    esc[quoteChar] = quoteStyle;
+                }
+               if (escapeSlash) {
+                    _altEscapesWithSlash[quoteChar] = esc;
+                } else {
+                    _altEscapesNoSlash[quoteChar] = esc;
                 }
-                _altEscapes[quoteChar] = esc;
-            }
-            return esc;
-        }
-
-        // @since 2.17
-        public int[] escapesFor(int quoteChar, boolean escapeSlash)
-        {
-            if (!escapeSlash) {
-                return escapesFor(quoteChar);
-            }
-            int[] esc = _altEscapesWithSlash[quoteChar];
-            if (esc == null) {
-                esc = escapesFor(quoteChar);
-                esc['/'] = '/';
-                _altEscapesWithSlash[quoteChar] = esc;
             }
             return esc;
         }

src/main/java/tools/jackson/core/json/JsonWriteFeature.java

@@ -103,11 +103,9 @@ public enum JsonWriteFeature
     /**
      * Feature that specifies whether {@link JsonGenerator} should escape forward slashes.
      * <p>
-     * Feature is disabled by default for Jackson 2.x version, and enabled by default in Jackson 3.0.
-     *
-     * @since 2.17
+     * Feature is enabled by default in Jackson 3.0 (was disabled in 2.x).
      */
-    ESCAPE_FORWARD_SLASHES(false),
+    ESCAPE_FORWARD_SLASHES(true),
 
     ;
 

src/test/java/tools/jackson/core/json/CustomQuoteCharTest.java

@@ -75,14 +75,14 @@ public void testAposQuotingWithCharBased() throws Exception
         _writeObject(g, "key", "It's \"fun\"");
         g.close();
         // should escape apostrophes but not quotes?
-        assertEquals("{'key':'It\\u0027s \\\"fun\\\"'}", w.toString());
+        assertEquals("{'key':'It\\'s \\\"fun\\\"'}", w.toString());
 
         // with Array
         w = new StringWriter();
         g = createGenerator(JSON_F, w);
         _writeArray(g, "It's a sin");
         g.close();
-        assertEquals("['It\\u0027s a sin']", w.toString());
+        assertEquals("['It\\'s a sin']", w.toString());
     }
 
     public void testAposQuotingWithByteBased() throws Exception
@@ -96,14 +96,14 @@ public void testAposQuotingWithByteBased() throws Exception
         _writeObject(g, "key", "It's \"fun\"");
         g.close();
         // should escape apostrophes but not quotes?
-        assertEquals("{'key':'It\\u0027s \\\"fun\\\"'}", out.toString("UTF-8"));
+        assertEquals("{'key':'It\\'s \\\"fun\\\"'}", out.toString("UTF-8"));
 
         // with Array
         out = new ByteArrayOutputStream();
         g = createGenerator(JSON_F, out);
         _writeArray(g, "It's a sin");
         g.close();
-        assertEquals("['It\\u0027s a sin']", out.toString("UTF-8"));
+        assertEquals("['It\\'s a sin']", out.toString("UTF-8"));
     }
 
     private void _writeObject(JsonGenerator g, String key, String value) throws Exception {

src/test/java/tools/jackson/core/json/TestCustomEscaping.java

@@ -217,8 +217,8 @@ private void _testEscapeCustom(boolean useStream, boolean stringAsChars,
         JsonFactory f = JsonFactory.builder()
                 .characterEscapes(new MyEscapes(customRepl))
                 .build();
-        final String STR_IN = "[abcd/"+((char) TWO_BYTE_ESCAPED)+"/"+((char) THREE_BYTE_ESCAPED)+"]";
-        final String STR_OUT = "[\\A\\u0062c"+customRepl+"/"+TWO_BYTE_ESCAPED_STRING+"/"+THREE_BYTE_ESCAPED_STRING+"]";
+        final String STR_IN = "[abcd-"+((char) TWO_BYTE_ESCAPED)+"-"+((char) THREE_BYTE_ESCAPED)+"]";
+        final String STR_OUT = "[\\A\\u0062c"+customRepl+"-"+TWO_BYTE_ESCAPED_STRING+"-"+THREE_BYTE_ESCAPED_STRING+"]";
         ByteArrayOutputStream bytes = new ByteArrayOutputStream();
         JsonGenerator g;
 

src/test/java/tools/jackson/core/write/JsonWriteFeatureEscapeForwardSlashTest.java

@@ -7,15 +7,28 @@
 import tools.jackson.core.JsonGenerator;
 import tools.jackson.core.ObjectWriteContext;
 import tools.jackson.core.json.JsonFactory;
+import tools.jackson.core.json.JsonGeneratorBase;
 import tools.jackson.core.json.JsonWriteFeature;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-/**
- * @since 2.17
- */
 public class JsonWriteFeatureEscapeForwardSlashTest
 {
+    @Test
+    public void testDefaultSettings() {
+        JsonFactory jsonF = new JsonFactory();
+        assertTrue(jsonF.isEnabled(JsonWriteFeature.ESCAPE_FORWARD_SLASHES));
+        try (JsonGeneratorBase g = (JsonGeneratorBase) jsonF.createGenerator(ObjectWriteContext.empty(),
+                new StringWriter())) {
+            assertTrue(g.isEnabled(JsonWriteFeature.ESCAPE_FORWARD_SLASHES));
+        }
+        try (JsonGeneratorBase g = (JsonGeneratorBase) jsonF.createGenerator(ObjectWriteContext.empty(),
+                new ByteArrayOutputStream())) {
+            assertTrue(g.isEnabled(JsonWriteFeature.ESCAPE_FORWARD_SLASHES));
+        }
+    }
+
     @Test
     public void testDontEscapeForwardSlash() throws Exception {
         final JsonFactory jsonF = JsonFactory.builder()