using double single quote in message format

Author: jugu

gp-res-filter/src/main/java/com/ibm/g11n/pipeline/resfilter/impl/JavaPropertiesResource.java

@@ -842,18 +842,10 @@ public static String ConvertSingleQuote(String inputStr, MessagePatternEscape ms
         }
 
         MessagePattern msgPat = null;
-        try {
-            msgPat = new MessagePattern(inputStr);
-        } catch (IllegalArgumentException e) {
-            // not a message format pattern - fall through
-        } catch (IndexOutOfBoundsException e) {
-            // might be a valid message format pattern, but cannot handle this - fall through
-        }
-        if (msgPat == null) {
-            // if the string cannot be parsed as a MessageFormat pattern string,
-            // just returns the input string.
+        if (!isMessagePatternCompatible(inputStr)) {
             return inputStr;
         }
+        msgPat = new MessagePattern(inputStr);
 
         if (msgPatEsc == MessagePatternEscape.AUTO) {
             // In AUTO mode, checks if the input string contains arguments.
@@ -875,57 +867,92 @@ public static String ConvertSingleQuote(String inputStr, MessagePatternEscape ms
 
 
         /***
-         * '{1}' -> '{1}'
+         * '{1}' -> ''{1}''
          * '{''}' -> '{''}'
          * '{'' -> '{''
          * '{'}' -> '{'}''
          * developer's -> developer''s
          */
 
         StringBuilder outputBuf = new StringBuilder();
-        int len = inputStr.length();
-        boolean keepQuote = false; //Flag for '{ or '}
-        int outstrIndex = 0;
-        int quoteIndex = 0;
-
-        while (quoteIndex < len) {
-            int idx = inputStr.indexOf("'", quoteIndex);
-
-            if (idx > -1) {
-                if (!keepQuote && idx + 1 < len
-                        && (inputStr.charAt(idx + 1) == '{' || inputStr.charAt(idx + 1) == '}')) {
-                    keepQuote = true;
-                    quoteIndex = idx + 2;
-                } else {
-                    if (keepQuote) { // '{ or '} is not closed yet
-                        if (idx + 1 < len && inputStr.charAt(idx + 1) == '\'') { //Ignore ''
-                            quoteIndex = idx+2;
-                        } else {
-                            keepQuote = false; //Close '{ or '} with this '
-                            quoteIndex = idx+1;
-                        }
-                    } else {
-                        outputBuf
-                            .append(inputStr.substring(outstrIndex, idx))
-                            .append("''");
-                        quoteIndex = idx+1;
-                        outstrIndex = quoteIndex;
+        
+        String[] quotedArr = inputStr.split("'");
+        // Split the sentence into string array based on single quote
+        // For each element of the array, 
+        //   if the element begins with a expression {.*
+        //   then check the following elements of the array to determine where the expression ends with }
+        //   if the expression ends on the same element, then it means that the content within {.*} 
+        //     doesn't contain any single quotes, and hence the expression can be easily appended/prepended with ''
+        //   Use single ' to append array elements between { and }
+        //   Use single ' to append on either end to wrap quoted {.*}, where the content inside { and } is having quotes.
+        //   This is still an incomplete fix, due to inconsistency in upload/download. However it handles most of the basic cases. 
+        outputBuf.append(quotedArr[0]);
+        boolean doDoubleQuote = true;
+        for  (int i = 1; i < quotedArr.length; i++) {
+            String interimStr = "";
+            if (quotedArr[i].startsWith("{")) {
+                if (quotedArr[i].endsWith("}")) {
+                    outputBuf.append("''").append(quotedArr[i]);
+                    if (i == quotedArr.length - 1) { // terminal element which ends with }'
+                        outputBuf.append("''");
+                    }
+                    continue;
+                }
+                doDoubleQuote = false;
+                interimStr = quotedArr[i]; 
+                int j = i + 1;
+                // look whether there is an ending "}" in the subsequent elements
+                for  (;j < quotedArr.length && !quotedArr[j].endsWith("}"); j++) {
+                    // any element in this range will be appended with single quote. 
+                    // we don't want to corrupt the pattern  inside {}
+                    interimStr = interimStr + "'" + quotedArr[j];
+                }
+                i = Math.min (j, quotedArr.length);
+                if (i < quotedArr.length) {
+                    outputBuf.append("'").append(interimStr).append("'").append(quotedArr[j]);
+                    if (i == quotedArr.length - 1 && inputStr.endsWith("'")) {
+                        outputBuf.append("'");
                     }
+                } else {
+                    outputBuf.append("'").append(interimStr);
                 }
             } else {
-                //No single quote is found
-                outputBuf.append(inputStr.substring(outstrIndex));
-                break;
+                if (doDoubleQuote) {
+                    outputBuf.append("''").append(quotedArr[i]);
+                } else {
+                    outputBuf.append("'").append(quotedArr[i]);
+                    doDoubleQuote = true;
+                }
             }
-        }//End while
+        }
 
-        if (quoteIndex >= len) {
-            outputBuf.append(inputStr.substring(outstrIndex));
+        // Falling back to input string, if the operations yielded a non message compatible string
+        if (!isMessagePatternCompatible(outputBuf.toString())) {
+            System.out.println(outputBuf.toString() + " is not message pattern compatible");
+            return inputStr;
         }
 
         return outputBuf.toString();
     }
 
+
+    public static boolean isMessagePatternCompatible(String inputStr) {
+        MessagePattern msgPat = null;
+        try {
+            msgPat = new MessagePattern(inputStr);
+        } catch (IllegalArgumentException e) {
+            // not a message format pattern - fall through
+        } catch (IndexOutOfBoundsException e) {
+            // might be a valid message format pattern, but cannot handle this - fall through
+        }
+        if (msgPat == null) {
+            // if the string cannot be parsed as a MessageFormat pattern string,
+            // just returns the input string.
+            return false;
+        }
+        return true;
+    }
+    
     public static int findSingleQuote(String inputStr, int start){
         return -1;
     }

gp-res-filter/src/test/java/com/ibm/g11n/pipeline/resfilter/impl/JavaPropertiesResourceTest.java

@@ -42,6 +42,7 @@
 import com.ibm.g11n.pipeline.resfilter.ResourceFilterException;
 import com.ibm.g11n.pipeline.resfilter.ResourceString;
 import com.ibm.g11n.pipeline.resfilter.ResourceString.ResourceStringComparator;
+import com.ibm.g11n.pipeline.resfilter.impl.JavaPropertiesResource.Encoding;
 import com.ibm.g11n.pipeline.resfilter.impl.JavaPropertiesResource.MessagePatternEscape;
 import com.ibm.g11n.pipeline.resfilter.impl.JavaPropertiesResource.PropDef;
 import com.ibm.g11n.pipeline.resfilter.impl.JavaPropertiesResource.PropDef.PropSeparator;
@@ -55,6 +56,9 @@ public class JavaPropertiesResourceTest {
 
     private static final File EXPECTED_WRITE_FILE = new File(
             "src/test/resource/resfilter/properties/write-output.properties");
+    
+    private static final File EXPECTED_WRITE_FILE_ALL = new File(
+            "src/test/resource/resfilter/properties/write-output-all.properties");
 
     private static final File EXPECTED_MERGE_FILE = new File(
             "src/test/resource/resfilter/properties/merge-output.properties");
@@ -146,6 +150,29 @@ public class JavaPropertiesResourceTest {
                 " a preceding backslash to ensure that they are properly loaded."));
         WRITE_BUNDLE = bundleBuilder.build();
     }
+    
+    private static LanguageBundle WRITE_BUNDLE_ALL;
+
+    static {
+        LanguageBundleBuilder bundleBuilder = new LanguageBundleBuilder(false);
+        bundleBuilder.addResourceString("A","This is a test.", 1);
+        bundleBuilder.addResourceString("B","This isn't a test.", 2);
+        bundleBuilder.addResourceString("C","This is't and won't be a test.", 3);
+        bundleBuilder.addResourceString("D","This isn't a '{0}'.", 4);
+        bundleBuilder.addResourceString("E","This isn't a '{0}' but a {1}.", 5);
+        bundleBuilder.addResourceString("F","This '{0}' isn't right.", 6);
+        bundleBuilder.addResourceString("G","This '{wasn't}' isn't right.",  7);
+        bundleBuilder.addResourceString("H","This '{''}' shouldn't be fine for '{0}'.", 8);
+        bundleBuilder.addResourceString("I","{0}", 9);
+        bundleBuilder.addResourceString("J","'{0}'", 10);
+        bundleBuilder.addResourceString("K","Using '{' and '}'", 11);
+        bundleBuilder.addResourceString("L","'{' is ok to use", 12);
+        bundleBuilder.addResourceString("M","The name '{0}' is already in use.",13);
+        bundleBuilder.addResourceString("N","length must be between '{min} and '{max}",14);
+        bundleBuilder.addResourceString("O","Password should not contain:#.-_'().",15);
+        bundleBuilder.addResourceString("P","[\\p'{'L'}'\\uFF65]", 16);
+        WRITE_BUNDLE_ALL = bundleBuilder.build();
+    }
 
     private static LinkedList<PropDef> EXPECTED_PROP_DEF_LIST;
 
@@ -322,10 +349,10 @@ public void testUnescapePropsValue() {
     private static final String[][] QUOTES_TEST_CASES =
         {
                 {"You're about to delete {0} rows.","You''re about to delete {0} rows."},
-                {"You're about to delete '{0}' rows in Mike's file {0}.","You''re about to delete '{0}' rows in Mike''s file {0}."},
+                {"You're about to delete '{0}' rows in Mike's file {0}.","You''re about to delete ''{0}'' rows in Mike''s file {0}."},
                 {"Log shows '{''}' in file {0}","Log shows '{''}' in file {0}"},
                 {"Log shows '{''} in file {0}","Log shows '{''} in file {0}"},
-                {"Log shows '{'}' in file {0}","Log shows '{'}'' in file {0}"},
+                {"Log shows '{'}' in file {0}","Log shows '{'}' in file {0}"},
                 {"Log shows '{'error'}' in file {0}","Log shows '{'error'}' in file {0}"},
                 {"Log shows '{''error''}' in file {0}","Log shows '{''error''}' in file {0}"},
                 {"File {0} shows '{''error''}'","File {0} shows '{''error''}'"},
@@ -402,4 +429,17 @@ public void testConvertDoubleSingleQuoteAuto(){
             assertEquals("ConvertDoubleSingleQuote(" + testCase[0] + ", ALL)", testCase[1], result);
         }
     }
+    
+    @Test
+    public void testWriteAllQuotes() throws IOException, ResourceFilterException {
+        File tempFile = File.createTempFile(this.getClass().getSimpleName(), ".properties");
+        JavaPropertiesResource res = new JavaPropertiesResource(Encoding.ISO_8859_1, MessagePatternEscape.ALL);
+        tempFile.deleteOnExit();
+        try (OutputStream os = new FileOutputStream(tempFile)) {
+            res.write(os, WRITE_BUNDLE_ALL, null);
+            os.flush();
+            // Ignore first line in both the files (first line empty in expected, first line contains timestamp in actual) 
+            assertTrue(ResourceTestUtil.compareFiles(EXPECTED_WRITE_FILE_ALL, tempFile, 1));
+        }
+    }
 }

gp-res-filter/src/test/resource/resfilter/properties/merge-output.properties

@@ -22,7 +22,7 @@ trailSPs = localized trailing SPs
 # tabs
 withTabs = localized Tab1\tTab2\tTab3\t
 # Quote
-withQuote = You''re about to delete '{1}' rows in Mike''s file {0}.
+withQuote = You''re about to delete ''{1}'' rows in Mike''s file {0}.
 # Not a Java MessageFormat param
 non-param = This {} is not a parameter.
 # A comment with backslashes - a\b\c \u3042\u3044 \t\n

gp-res-filter/src/test/resource/resfilter/properties/write-output-all.properties

@@ -0,0 +1,17 @@
+
+A = This is a test.
+B = This isn''t a test.
+C = This is''t and won''t be a test.
+D = This isn''t a ''{0}''.
+E = This isn''t a ''{0}'' but a {1}.
+F = This ''{0}'' isn''t right.
+G = This '{wasn't}' isn''t right.
+H = This '{''}' shouldn''t be fine for ''{0}''.
+I = {0}
+J = ''{0}''
+K = Using '{' and '}'
+L = '{' is ok to use
+M = The name ''{0}'' is already in use.
+N = length must be between '{min} and '{max}
+O = Password should not contain\:\#.-_''().
+P = [\\p'{'L'}'\\uFF65]

gp-res-filter/src/test/resource/resfilter/properties/write-output.properties

@@ -23,7 +23,7 @@ trailSPs = localized trailing SPs
 # tabs
 withTabs = localized Tab1\tTab2\tTab3\t
 # Quote
-withQuote = You''re about to delete '{1}' rows in Mike''s file {0}.
+withQuote = You''re about to delete ''{1}'' rows in Mike''s file {0}.
 # Not a Java MessageFormat param
 non-param = This {} is not a parameter.
 # A comment with backslashes - a\b\c \u3042\u3044 \t\n