Throw on square brackets in field path

Author: jbaiera

server/src/main/java/org/elasticsearch/ingest/IngestDocument.java

@@ -44,7 +44,6 @@
 import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 /**
  * Represents a single document being captured before indexing and holds the source and metadata (like id, type and index).
@@ -1290,55 +1289,6 @@ public String getFieldName() {
 
     private static final class FieldPath {
 
-        private record Element(String fieldName, Integer arrayIndex) {
-            private static final String EMPTY_STRING = "";
-
-            /**
-             * Creates a new FieldPath Element which corresponds to a regular part of a field path.
-             * @param fieldName name of the field to access, or a string to use for array indexing if running in CLASSIC access pattern.
-             * @return A field name element
-             */
-            static Element field(String fieldName) {
-                Objects.requireNonNull(fieldName, "fieldName cannot be null");
-                if (fieldName.isEmpty()) {
-                    throw new IllegalArgumentException("fieldName cannot be empty");
-                }
-                return new Element(fieldName, null);
-            }
-
-            /**
-             * Creates a new FieldPath Element which corresponds to an array index specified by the square bracket syntax available
-             * when using the {@link IngestPipelineFieldAccessPattern#FLEXIBLE} access pattern.
-             * @param arrayIndex array index specified in square brackets
-             * @return An array index element
-             */
-            static Element index(int arrayIndex) {
-                if (arrayIndex < 0) {
-                    throw new IndexOutOfBoundsException(arrayIndex);
-                }
-                return new Element(EMPTY_STRING, arrayIndex);
-            }
-
-            /**
-             * @return true if this element is for accessing a regular field
-             */
-            boolean isFieldName() {
-                return fieldName.isEmpty() == false && arrayIndex == null;
-            }
-
-            /**
-             * @return true if this element is for an array index used for the FLEXIBLE access pattern
-             */
-            boolean isArrayIndex() {
-                return isFieldName() == false;
-            }
-
-            @Override
-            public String toString() {
-                return isFieldName() ? fieldName : "[" + arrayIndex + "]";
-            }
-        }
-
         /**
          * A compound cache key for tracking previously parsed field paths
          * @param path The field path as given by the caller
@@ -1373,7 +1323,7 @@ static FieldPath of(String path, IngestPipelineFieldAccessPattern accessPattern)
             return res;
         }
 
-        private final Element[] pathElements;
+        private final String[] pathElements;
         private final boolean useIngestContext;
 
         // you shouldn't call this directly, use the FieldPath.of method above instead!
@@ -1394,12 +1344,12 @@ private FieldPath(String path, IngestPipelineFieldAccessPattern accessPattern) {
             this.pathElements = processPathParts(path, pathParts, accessPattern);
         }
 
-        private static Element[] processPathParts(String fullPath, String[] pathParts, IngestPipelineFieldAccessPattern accessPattern) {
+        private static String[] processPathParts(String fullPath, String[] pathParts, IngestPipelineFieldAccessPattern accessPattern) {
             if (pathParts.length == 1 && pathParts[0].isEmpty()) {
                 throw new IllegalArgumentException("path [" + fullPath + "] is not valid");
             }
             return switch (accessPattern) {
-                case CLASSIC -> Arrays.stream(pathParts).map(Element::field).toArray(Element[]::new);
+                case CLASSIC -> pathParts;
                 case FLEXIBLE -> parseFlexibleFields(fullPath, pathParts);
             };
         }
@@ -1411,46 +1361,16 @@ private static Element[] processPathParts(String fullPath, String[] pathParts, I
          * @param pathParts The tokenized field path to parse
          * @return An array of Elements
          */
-        private static Element[] parseFlexibleFields(String fullPath, String[] pathParts) {
-            return Arrays.stream(pathParts)
-                .flatMap(pathPart -> {
-                    int openBracket = pathPart.indexOf('[');
-                    if (openBracket == -1) {
-                        return Stream.of(Element.field(pathPart));
-                    } else if (openBracket == 0) {
-                        throw new IllegalArgumentException("path [" + fullPath + "] is not valid");
-                    } else {
-                        List<Element> resultElements = new ArrayList<>();
-                        String rootField = pathPart.substring(0, openBracket);
-                        resultElements.add(Element.field(rootField));
-
-                        boolean elementsRemain = true;
-                        while (elementsRemain) {
-                            int closeBracket = pathPart.indexOf(']', openBracket);
-                            if (closeBracket <= openBracket) {
-                                throw new IllegalArgumentException("path [" + fullPath + "] is not valid");
-                            }
-
-                            String rawIndex = pathPart.substring(openBracket + 1, closeBracket);
-                            try {
-                                resultElements.add(Element.index(Integer.parseInt(rawIndex)));
-                            } catch (NumberFormatException numberFormatException) {
-                                throw new IllegalArgumentException("path [" + fullPath + "] is not valid");
-                            }
-
-                            if (closeBracket == pathPart.length() - 1) {
-                                elementsRemain = false;
-                            } else {
-                                if (pathPart.charAt(closeBracket + 1) != '[') {
-                                    throw new IllegalArgumentException("path [" + fullPath + "] is not valid");
-                                }
-                                openBracket = closeBracket + 1;
-                            }
-                        }
-                        return resultElements.stream();
-                    }
-                })
-                .toArray(Element[]::new);
+        private static String[] parseFlexibleFields(String fullPath, String[] pathParts) {
+            boolean invalidPath = Arrays.stream(pathParts).anyMatch(pathPart -> {
+                int openBracket = pathPart.indexOf('[');
+                int closedBracket = pathPart.indexOf(']');
+                return openBracket != -1 && closedBracket != -1;
+            });
+            if (invalidPath) {
+                throw new IllegalArgumentException("path [" + fullPath + "] is not valid");
+            }
+            return pathParts;
         }
 
         public Object initialContext(IngestDocument document) {