Introduce SegmentParser.findAll, which will find all paths based on a modulepattern

Author: rfscholte

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

@@ -0,0 +1,167 @@
+package org.codehaus.plexus.languages.java.jpms;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+/**
+ * This class helps with the module module-pattern form of the module source path.
+ *
+ *
+ * @See https://docs.oracle.com/en/java/javase/23/docs/specs/man/javac.html#the-module-source-path-option
+ */
+class SegmentParser {
+
+    private Consumer<Element> nextAction;
+
+    protected List<String> findAll(String segment) {
+        StringBuilder value = new StringBuilder();
+
+        Root root = new Root();
+        nextAction = root::element;
+
+        Deque<Block> blocks = new ArrayDeque<>();
+
+        for (int i = 0; i < segment.length(); i++) {
+            char c = segment.charAt(i);
+            switch (c) {
+                case '{': {
+                    Block b = new Block(value.toString());
+
+                    nextAction.accept(b);
+
+                    blocks.push(b);
+
+                    nextAction = b::element;
+
+                    value = new StringBuilder();
+
+                    break;
+                }
+                case ',': {
+                    nextAction.accept(new Value(value.toString()));
+
+                    Block b = blocks.peek();
+
+                    nextAction = b::element;
+
+                    value = new StringBuilder();
+
+                    break;
+                }
+                case '}': {
+                    nextAction.accept(new Value(value.toString()));
+
+                    Block b = blocks.poll();
+
+                    nextAction = b::tail;
+
+                    value = new StringBuilder();
+
+                    break;
+                }
+                default:
+                    value.append(c);
+
+                    break;
+            }
+        }
+
+        if (value.length() > 0) {
+            nextAction.accept(new Value(value.toString()));
+        }
+
+        return root.resolvePaths();
+    }
+
+    private interface Element {
+        List<String> resolvePaths(List<String> bases);
+    }
+
+    private final class Value implements Element {
+
+        private final String value;
+
+        public Value(String value) {
+            this.value = value;
+        }
+
+        @Override
+        public List<String> resolvePaths(List<String> bases) {
+            return bases.stream().map(b -> b + value).collect(Collectors.toList());
+        }
+
+        @Override
+        public String toString() {
+            return "Value [value=" + value + "]";
+        }
+    }
+
+    private final class Block implements Element {
+
+        private final String value;
+
+        private List<Element> elements = new ArrayList<>();
+
+        private Element tail;
+
+        public Block(String value) {
+            this.value = value;
+        }
+
+        public void element(Element element) {
+            elements.add(element);
+        }
+
+        public void tail(Element element) {
+            tail = element;
+        }
+
+        @Override
+        public List<String> resolvePaths(List<String> bases) {
+            final List<String> valuedBases = bases.stream().map(b -> b + value).collect(Collectors.toList());
+
+            List<String> newBases;
+            if (elements.isEmpty()) {
+                newBases = valuedBases;
+            } else {
+                newBases = elements.stream()
+                        .flatMap(e -> e.resolvePaths(valuedBases).stream())
+                        .collect(Collectors.toList());
+            }
+
+            if (tail == null) {
+                return newBases;
+            } else {
+                return tail.resolvePaths(newBases);
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "Block [value=" + value + ", elements=" + elements + ", tail=" + tail + "]";
+        }
+    }
+
+    private final class Root {
+
+        private Element element;
+
+        public void element(Element element) {
+            this.element = element;
+        }
+
+        public List<String> resolvePaths() {
+            return element.resolvePaths(Arrays.asList(""));
+        }
+
+        @Override
+        public String toString() {
+            return "Root [element=" + element + "]";
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+package org.codehaus.plexus.languages.java.jpms;
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+class SegmentParserTest {
+
+    @ParameterizedTest
+    @MethodSource
+    void findAll(String segment, String... expectedValues) {
+        SegmentParser parser = new SegmentParser();
+        assertThat(parser.findAll(segment)).containsExactlyInAnyOrder(expectedValues);
+    }
+
+    static Stream<Arguments> findAll() {
+        return Stream.of(
+                Arguments.of("foo", new String[] {"foo"}),
+                Arguments.of("foo/{bar,baz}", new String[] {"foo/bar", "foo/baz"}),
+                Arguments.of("foo/{bar,baz}/com", new String[] {"foo/bar/com", "foo/baz/com"}),
+                Arguments.of("foo/{bar,baz}/com/{1,2,3}/zzz", new String[] {
+                    "foo/bar/com/1/zzz",
+                    "foo/baz/com/1/zzz",
+                    "foo/bar/com/2/zzz",
+                    "foo/baz/com/2/zzz",
+                    "foo/bar/com/3/zzz",
+                    "foo/baz/com/3/zzz"
+                }),
+                Arguments.of("foo/{bar,baz/com/{1,2,3}/yyy}/zzz", new String[] {
+                    "foo/bar/zzz", "foo/baz/com/1/yyy/zzz", "foo/baz/com/2/yyy/zzz", "foo/baz/com/3/yyy/zzz"
+                }),
+                Arguments.of("{foo/{bar},zzz}", new String[] {"foo/bar", "zzz"}));
+    }
+}