Parse property values starting with the delimiter character (#4065)

* Correctly parse property values starting with delimiter character Fixes #4026. * avoid arithmetic on state operations Avoid arithmetic operations with the state variable and rather assign the new value. Also convert to enum to make the states more easy to understand for the next author.
openrewrite · Mar 2, 2024 · ba636bb · ba636bb
1 parent ee49696
commit ba636bb
Show file tree

Hide file tree

Showing 2 changed files with 51 additions and 21 deletions.
diff --git a/rewrite-properties/src/main/java/org/openrewrite/properties/PropertiesParser.java b/rewrite-properties/src/main/java/org/openrewrite/properties/PropertiesParser.java
@@ -179,48 +179,58 @@ private Properties.Comment commentFromLine(String line, String prefix, Propertie
         );
     }
 
+    static enum State {
+        WHITESPACE_BEFORE_KEY,
+        KEY,
+        KEY_OR_WHITESPACE,
+        WHITESPACE_OR_DELIMITER,
+        WHITESPACE_OR_VALUE,
+        VALUE,
+        VALUE_OR_TRAILING
+    }
+
     private Properties.Entry entryFromLine(String line, String prefix, StringBuilder trailingWhitespaceBuffer) {
         StringBuilder prefixBuilder = new StringBuilder(prefix),
                 key = new StringBuilder(),
                 equalsPrefix = new StringBuilder(),
                 valuePrefix = new StringBuilder(),
                 value = new StringBuilder();
-
+        
         Properties.Entry.Delimiter delimiter = Properties.Entry.Delimiter.NONE;
         char prev = '$';
-        int state = 0;
+        State state = State.WHITESPACE_BEFORE_KEY;
         for (int i = 0; i < line.length(); i++) {
             char c = line.charAt(i);
             switch (state) {
-                case 0:
+                case WHITESPACE_BEFORE_KEY:
                     if (Character.isWhitespace(c)) {
                         prefixBuilder.append(c);
                         break;
                     }
-                    state++;
-                case 1:
+                    state = State.KEY;
+                case KEY:
                     if (c == '=' || c == ':') {
                         if (prev == '\\') {
                             key.append(c);
                             break;
                         } else {
                             delimiter = Properties.Entry.Delimiter.getDelimiter(String.valueOf(c));
-                            state += 3;
+                            state = State.WHITESPACE_OR_VALUE;
                             break;
                         }
                     } else if (c == '\\') {
                         key.append(c);
-                        state++;
+                        state = State.KEY_OR_WHITESPACE;
                         break;
                     } else if (!Character.isWhitespace(c)) {
                         key.append(c);
                         break;
                     } else {
                         equalsPrefix.append(c);
-                        state += 2;
+                        state = State.WHITESPACE_OR_DELIMITER;
                         break;
                     }
-                case 2:
+                case KEY_OR_WHITESPACE:
                     if (Character.isWhitespace(c)) {
                         trailingWhitespaceBuffer.append(c);
                         break;
@@ -229,40 +239,43 @@ private Properties.Entry entryFromLine(String line, String prefix, StringBuilder
                         key.append(trailingWhitespaceBuffer);
                         trailingWhitespaceBuffer.setLength(0);
                         key.append(c);
-                        state--;
+                        state = State.KEY;
                         break;
                     }
-                case 3:
+                case WHITESPACE_OR_DELIMITER:
                     if (Character.isWhitespace(c)) {
                         equalsPrefix.append(c);
                         break;
                     } else if (c == '=' || c == ':') {
                         delimiter = Properties.Entry.Delimiter.getDelimiter(String.valueOf(c));
+                        state = State.WHITESPACE_OR_VALUE;
+                        break;
                     }
-                    state++;
-                case 4:
-                    if (c == '=' || c == ':') {
-                        continue;
-                    } else if (Character.isWhitespace(c)) {
+                case WHITESPACE_OR_VALUE:
+                    if (Character.isWhitespace(c)) {
                         valuePrefix.append(c);
                         break;
                     }
-                    state++;
-                case 5:
+                    else {
+                        value.append(c);
+                        state = State.VALUE;
+                        break;
+                    }
+                case VALUE:
                     if (!Character.isWhitespace(c)) {
                         value.append(c);
                         break;
                     }
-                    state++;
-                case 6:
+                    state = State.VALUE_OR_TRAILING;
+                case VALUE_OR_TRAILING:
                     if (Character.isWhitespace(c)) {
                         trailingWhitespaceBuffer.append(c);
                     } else {
                         // multi-word or continuation line value
                         value.append(trailingWhitespaceBuffer);
                         trailingWhitespaceBuffer.setLength(0);
                         value.append(c);
-                        state--;
+                        state = State.VALUE;
                         break;
                     }
             }

diff --git a/rewrite-properties/src/test/java/org/openrewrite/properties/PropertiesParserTest.java b/rewrite-properties/src/test/java/org/openrewrite/properties/PropertiesParserTest.java
@@ -233,6 +233,23 @@ void trailingDoubleSlash() {
         );
     }
 
+    @Issue("https://github.com/openrewrite/rewrite/issues/4026")
+    @Test
+    void repeatedDelimiter() {
+        rewriteRun(
+          properties(
+            """
+              key1==value1
+              key2::value2
+              key3======value3
+              key4=:value4
+              key5 = = value5
+              """,
+            containsValues("=value1", ":value2", "=====value3", ":value4", "= value5")
+          )
+        );
+    }
+
     private static Consumer<SourceSpec<Properties.File>> containsValues(String... valueAssertions) {
         return spec -> spec.beforeRecipe(props -> {
             List<String> values = TreeVisitor.collect(new PropertiesVisitor<>() {