Add exceptions for unbalanced braces

Author: rfscholte

plexus-java/src/main/java/org/codehaus/plexus/languages/java/jpms/ModuleSourcePathSupport.java

@@ -0,0 +1,30 @@
+package org.codehaus.plexus.languages.java.jpms;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ModuleSourcePathSupport {
+
+    /**
+     *
+     *
+     * @param segments the list of segments, as split by the path-separator
+     * @return all possible combinations
+     */
+    public List<String> expand(List<String> segments) {
+        SegmentParser parser = new SegmentParser();
+
+        List<String> result = new ArrayList<>();
+
+        for (String segment : segments) {
+            try {
+                result.addAll(parser.expandBraces(segment));
+            } catch (RuntimeException e) {
+                throw new IllegalArgumentException("Failed to parse " + segment + ": " + e.getMessage());
+            }
+        }
+
+        return segments.stream().flatMap(e -> parser.expandBraces(e).stream()).collect(Collectors.toList());
+    }
+}

plexus-java/src/main/java/org/codehaus/plexus/languages/java/jpms/SegmentParser.java

@@ -5,6 +5,7 @@
 import java.util.Arrays;
 import java.util.Deque;
 import java.util.List;
+import java.util.NoSuchElementException;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
@@ -16,9 +17,35 @@
  */
 class SegmentParser {
 
+    private static final char MODULENAME_MARKER = '*';
+
     private Consumer<Element> nextAction;
 
-    protected List<String> findAll(String segment) {
+    /**
+     * Each segment containing curly braces of the form
+     *
+     * <code>string1{alt1 ( ,alt2 )* } string2</code>
+     *
+     * is considered to be replaced by a series of segments formed by "expanding" the braces:
+     *
+     * <ul>
+     * <li><code>string1 alt1 string2</code></li>
+     * <li><code>string1 alt2 string2</code></li>
+     * </ul>
+     * and so on...
+     * <p>
+     * The braces may be nested.
+     * </p>
+     * <p>
+     * This rule is applied for all such usages of braces.
+     * </p>
+     *
+     * @param segment the segment to expand
+     * @return all expanded segments
+     * @throws IllegalArgumentException if braces are unbalanced
+     * @see <a href="https://docs.oracle.com/en/java/javase/23/docs/specs/man/javac.html#the-module-source-path-option">https://docs.oracle.com/en/java/javase/23/docs/specs/man/javac.html#the-module-source-path-option</a>
+     */
+    protected List<String> expandBraces(String segment) {
         StringBuilder value = new StringBuilder();
 
         Root root = new Root();
@@ -56,9 +83,13 @@ protected List<String> findAll(String segment) {
                 case '}': {
                     nextAction.accept(new Value(value.toString()));
 
-                    Block b = blocks.poll();
+                    try {
+                        Block b = blocks.pop();
 
-                    nextAction = b::tail;
+                        nextAction = b::tail;
+                    } catch (NoSuchElementException e) {
+                        throw new IllegalArgumentException("Unbalanced braces, missing {");
+                    }
 
                     value = new StringBuilder();
 
@@ -71,6 +102,10 @@ protected List<String> findAll(String segment) {
             }
         }
 
+        if (blocks.size() > 0) {
+            throw new IllegalArgumentException("Unbalanced braces, missing }");
+        }
+
         if (value.length() > 0) {
             nextAction.accept(new Value(value.toString()));
         }
@@ -80,6 +115,8 @@ protected List<String> findAll(String segment) {
 
     private interface Element {
         List<String> resolvePaths(List<String> bases);
+
+        boolean hasModuleNameMarker();
     }
 
     private final class Value implements Element {
@@ -95,6 +132,11 @@ public List<String> resolvePaths(List<String> bases) {
             return bases.stream().map(b -> b + value).collect(Collectors.toList());
         }
 
+        @Override
+        public boolean hasModuleNameMarker() {
+            return value.indexOf(MODULENAME_MARKER) >= 0;
+        }
+
         @Override
         public String toString() {
             return "Value [value=" + value + "]";
@@ -141,6 +183,11 @@ public List<String> resolvePaths(List<String> bases) {
             }
         }
 
+        @Override
+        public boolean hasModuleNameMarker() {
+            return value.indexOf(MODULENAME_MARKER) >= 0;
+        }
+
         @Override
         public String toString() {
             return "Block [value=" + value + ", elements=" + elements + ", tail=" + tail + "]";

plexus-java/src/test/java/org/codehaus/plexus/languages/java/jpms/SegmentParserTest.java

@@ -1,5 +1,6 @@
 package org.codehaus.plexus.languages.java.jpms;
 
+import java.nio.file.Path;
 import java.util.stream.Stream;
 
 import org.junit.jupiter.params.ParameterizedTest;
@@ -13,12 +14,12 @@ class SegmentParserTest {
 
     @ParameterizedTest
     @MethodSource
-    void findAll(String segment, String... expectedValues) {
+    void expandBraces(String segment, String... expectedValues) {
         SegmentParser parser = new SegmentParser();
-        assertThat(parser.findAll(segment)).containsExactlyInAnyOrder(expectedValues);
+        assertThat(parser.expandBraces(segment)).containsExactlyInAnyOrder(expectedValues);
     }
 
-    static Stream<Arguments> findAll() {
+    static Stream<Arguments> expandBraces() {
         return Stream.of(
                 Arguments.of("foo", new String[] {"foo"}),
                 Arguments.of("foo/{bar,baz}", new String[] {"foo/bar", "foo/baz"}),
@@ -36,4 +37,43 @@ static Stream<Arguments> findAll() {
                 }),
                 Arguments.of("{foo/{bar},zzz}", new String[] {"foo/bar", "zzz"}));
     }
+
+    @ParameterizedTest
+    @MethodSource
+    void expandBraces_exceptions(String segment, String exceptionMessage) {
+        SegmentParser parser = new SegmentParser();
+        IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> parser.expandBraces(segment));
+        assertThat(e.getMessage()).isEqualTo(exceptionMessage);
+    }
+
+    static Stream<Arguments> expandBraces_exceptions() {
+        return Stream.of(
+                Arguments.of("{", "Unbalanced braces, missing }"), Arguments.of("}", "Unbalanced braces, missing {"));
+    }
+
+    void bla() {
+        String seg = "";
+        int markStart = 0;
+
+        Path prefix;
+        if (markStart == 0) {
+            prefix = getPath("");
+        } else if (isSeparator(seg.charAt(markStart - 1))) {
+            prefix = getPath(seg.substring(0, markStart - 1));
+        } else {
+            throw new IllegalArgumentException("illegal use of " + MARKER + " in " + seg);
+        }
+
+        prefix.compareTo(null);
+    }
+
+    static String MARKER;
+
+    Path getPath(String s) {
+        return null;
+    }
+
+    boolean isSeparator(char c) {
+        return true;
+    }
 }