[Java] Make CucumberExpressionParser.parse public

Fixes: #51

By doing this we're exposing the public API surface. If #41 ever gets
implemented, it may require a change to the AST. We can live with that.

Author: mpkorstanje

CHANGELOG.md

@@ -6,6 +6,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
+### Added
+- [Java] Expose Cucumber
 
 ## [18.0.1] - 2024-10-28
 ### Fixed

java/src/main/java/io/cucumber/cucumberexpressions/Ast.java

@@ -4,18 +4,17 @@
 import java.util.Objects;
 import java.util.StringJoiner;
 
-import static java.util.Arrays.asList;
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.joining;
 
-final class Ast {
+public final class Ast {
 
-    private static final char escapeCharacter = '\\';
-    private static final char alternationCharacter = '/';
-    private static final char beginParameterCharacter = '{';
-    private static final char endParameterCharacter = '}';
-    private static final char beginOptionalCharacter = '(';
-    private static final char endOptionalCharacter = ')';
+    public static final char escapeCharacter = '\\';
+    public static final char alternationCharacter = '/';
+    public static final char beginParameterCharacter = '{';
+    public static final char endParameterCharacter = '}';
+    public static final char beginOptionalCharacter = '(';
+    public static final char endOptionalCharacter = ')';
 
     interface Located {
         int start();
@@ -24,7 +23,7 @@ interface Located {
 
     }
 
-    static final class Node implements Located {
+    public static final class Node implements Located {
 
         private final Type type;
         private final List<Node> nodes;
@@ -48,7 +47,7 @@ private Node(Type type, int start, int end, List<Node> nodes, String token) {
             this.end = end;
         }
 
-        enum Type {
+        public enum Type {
             TEXT_NODE,
             OPTIONAL_NODE,
             ALTERNATION_NODE,
@@ -65,15 +64,21 @@ public int end() {
             return end;
         }
 
-        List<Node> nodes() {
+        /**
+         * @return child nodes, {@code null} if a leaf-node
+         */
+        public List<Node> nodes() {
             return nodes;
         }
 
-        Type type() {
+        public Type type() {
             return type;
         }
 
-        String text() {
+        /**
+         * @return the 
+         */
+        public String text() {
             if (nodes == null)
                 return token;
 

java/src/main/java/io/cucumber/cucumberexpressions/CucumberExpressionParser.java

@@ -28,7 +28,10 @@
 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
 
-final class CucumberExpressionParser {
+/**
+ * A parser for Cucumber expressions
+ */
+public final class CucumberExpressionParser {
 
     /*
      * text := whitespace | ')' | '}' | .
@@ -160,7 +163,13 @@ final class CucumberExpressionParser {
             )
     );
 
-    Node parse(String expression) {
+    /**
+     * Parses as Cucumber expression into an AST of {@link Node nodes}. 
+     * @param expression the expression to parse
+     * @return an AST of nodes
+     * @throws CucumberExpressionException if the expression could not be parsed
+     */
+    public Node parse(String expression) {
         CucumberExpressionTokenizer tokenizer = new CucumberExpressionTokenizer();
         List<Token> tokens = tokenizer.tokenize(expression);
         Result result = cucumberExpressionParser.parse(expression, tokens, 0);

java/src/main/java/io/cucumber/cucumberexpressions/GroupBuilder.java

@@ -9,7 +9,7 @@ final class GroupBuilder {
     private final List<GroupBuilder> groupBuilders = new ArrayList<>();
     private boolean capturing = true;
     private String source;
-    private int startIndex;
+    private final int startIndex;
     private int endIndex;
 
     GroupBuilder(int startIndex) {

java/src/main/java/io/cucumber/cucumberexpressions/RegularExpression.java

@@ -48,7 +48,7 @@ public List<Argument<?>> match(String text, Type... typeHints) {
 
             // When there is a conflict between the type hint from the regular expression and the method
             // prefer the parameter type associated with the regular expression. This ensures we will
-            // use the internal/user registered parameter transformer rather then the default.
+            // use the internal/user registered parameter transformer rather than the default.
             //
             // Unless the parameter type indicates it is the stronger type hint.
             if (parameterType != null && hasTypeHint && !parameterType.useRegexpMatchAsStrongTypeHint()) {

java/src/main/java/io/cucumber/cucumberexpressions/TreeRegexp.java

@@ -91,7 +91,7 @@ Group match(CharSequence s) {
         return groupBuilder.build(matcher, IntStream.rangeClosed(0, matcher.groupCount()).iterator());
     }
 
-    public GroupBuilder getGroupBuilder() {
+    GroupBuilder getGroupBuilder() {
         return groupBuilder;
     }
 

java/src/test/java/io/cucumber/cucumberexpressions/CucumberExpressionTest.java

@@ -15,6 +15,7 @@
 import java.lang.reflect.Type;
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.nio.file.DirectoryStream;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -38,7 +39,10 @@ class CucumberExpressionTest {
 
     private static List<Path> acceptance_tests_pass() throws IOException {
         List<Path> paths = new ArrayList<>();
-        newDirectoryStream(Paths.get("..", "testdata", "cucumber-expression", "matching")).forEach(paths::add);
+        Path path = Paths.get("..", "testdata", "cucumber-expression", "matching");
+        try (DirectoryStream<Path> directories = newDirectoryStream(path)){
+            directories.forEach(paths::add);
+        }
         paths.sort(Comparator.naturalOrder());
         return paths;
     }