Path pattern builder

common/src/main/java/com/linecorp/centraldogma/common/DefaultPathPattern.java

@@ -17,6 +17,7 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 
+import java.util.List;
 import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -44,12 +45,19 @@ final class DefaultPathPattern implements PathPattern {
         this.patterns = patterns.stream()
                                 .peek(DefaultPathPattern::validatePathPattern)
                                 .filter(pattern -> !pattern.isEmpty())
-                                .map(pattern -> {
-                                    if (pattern.charAt(0) != '/') {
-                                        return "/**/" + pattern;
-                                    }
-                                    return pattern;
-                                }).collect(Collectors.joining(","));
+                                .map(DefaultPathPattern::normalizePattern)
+                                .collect(Collectors.joining(","));
+    }
+
+    DefaultPathPattern(List<PathPattern> verifiedPatterns) {
+        patterns = verifiedPatterns.stream()
+                                   .map(PathPattern::patternString)
+                                   .collect(Collectors.joining(","));
+    }
+
+    DefaultPathPattern(String pattern) {
+        validatePathPattern(pattern);
+        patterns = normalizePattern(pattern);
     }
 
     private DefaultPathPattern(String patterns, String encoded) {
@@ -100,6 +108,13 @@ private static String validatePathPattern(String pattern) {
         return pattern;
     }
 
+    private static String normalizePattern(String pattern) {
+        if (pattern.charAt(0) != '/') {
+            return "/**/" + pattern;
+        }
+        return pattern;
+    }
+
     @Override
     public String toString() {
         return MoreObjects.toStringHelper(this)

common/src/main/java/com/linecorp/centraldogma/common/PathPattern.java

@@ -15,10 +15,12 @@
  */
 package com.linecorp.centraldogma.common;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static com.linecorp.centraldogma.common.DefaultPathPattern.ALL;
 import static com.linecorp.centraldogma.common.DefaultPathPattern.allPattern;
 import static java.util.Objects.requireNonNull;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Streams;
 
@@ -36,6 +38,13 @@
  */
 public interface PathPattern {
 
+    /**
+     * Returns a newly created {@link PathPatternBuilder}.
+     */
+    static PathPatternBuilder builder() {
+        return new PathPatternBuilder();
+    }
+
     /**
      * Returns the path pattern that represents all files.
      */
@@ -50,6 +59,17 @@ static PathPattern of(String... patterns) {
         return of(ImmutableSet.copyOf(requireNonNull(patterns, "patterns")));
     }
 
+    /**
+     * Creates a path pattern with the {@code pathPatterns}.
+     */
+    static PathPattern of(PathPattern... pathPatterns) {
+        checkArgument(pathPatterns.length > 0, "pathPatterns");
+        if (pathPatterns.length == 1) {
+            return pathPatterns[0];
+        }
+        return new DefaultPathPattern(ImmutableList.copyOf(pathPatterns));
+    }
+
     /**
      * Creates a path pattern with the {@code patterns}.
      */
@@ -62,6 +82,34 @@ static PathPattern of(Iterable<String> patterns) {
         return new DefaultPathPattern(ImmutableSet.copyOf(patterns));
     }
 
+    /**
+     * Returns the path pattern for matching file(s) ending in {@code filename}.
+     */
+    static PathPattern endsWith(String filename) {
+        return builder().endsWith(filename).build();
+    }
+
+    /**
+     * Returns the path pattern for file(s) that start with {@code dirPath}.
+     */
+    static PathPattern startsWith(String dirPath) {
+        return builder().startsWith(dirPath).build();
+    }
+
+    /**
+     * Returns the path pattern for file(s) that contains {@code dirPath}.
+     */
+    static PathPattern contains(String dirPath) {
+        return builder().contains(dirPath).build();
+    }
+
+    /**
+     * Returns the path pattern for file(s) with {@code extension}.
+     */
+    static PathPattern hasExtension(String extension) {
+        return builder().hasExtension(extension).build();
+    }
+
     /**
      * Returns the path pattern that concatenates the {@code patterns} using ','.
      */

common/src/main/java/com/linecorp/centraldogma/common/PathPatternBuilder.java

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2023 LINE Corporation
+ *
+ * LINE Corporation licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package com.linecorp.centraldogma.common;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static java.util.Objects.requireNonNull;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Builds a new {@link PathPattern}.
+ *
+ * <h2>Example</h2>
+ * <pre>{@code
+ * final PathPattern pathPattern =
+ *         PathPattern.builder()
+ *                    .startsWith("/foo/bar")
+ *                    .contains("/ext")
+ *                    .hasExtension("json")
+ *                    .build();
+ * }</pre>
+ */
+public final class PathPatternBuilder {
+    @Nullable
+    private PathPatternOption startPattern;
+    private final List<PathPatternOption> innerPatterns = new ArrayList<>();
+    @Nullable
+    private PathPatternOption endPattern;
+
+    PathPatternBuilder() {}
+
+    /**
+     * Ensures the file name component matches the specified {@code filename}.
+     * For example, `endWith("foo.txt")` will match `/foo.txt`, `/alice/foo.txt` and
+     * `/alice/bob/foo.txt`, but not `/barfoo.txt`.
+     *
+     * <p>This option can only be specified once; multiple declarations will override one another.
+     *
+     * <p>Note: this option and {@link PathPatternBuilder#hasExtension(String)} are mutually exclusive.
+     * When both are specified, the latter-most option will override the former.
+     */
+    public PathPatternBuilder endsWith(String filename) {
+        requireNonNull(filename, "filename");
+        endPattern = PathPatternOptions.ENDS_WITH.apply(filename);
+        return this;
+    }
+
+    /**
+     * Ensures the file extension component matches the specified {@code extension}.
+     * For example, `hasExtension("json")` will match `mux.json`, `/bar/mux.json` and
+     * `/alice/bar/mux.json` but not `/json.txt`.
+     *
+     * <p>This option can only be specified once; multiple declarations will override one another.
+     *
+     * <p>Note: this option and {@link PathPatternBuilder#endsWith(String)} are mutually exclusive.
+     *  When both are specified, the latter-most option will override the former.
+     */
+    public PathPatternBuilder hasExtension(String extension) {
+        requireNonNull(extension, "extension");
+        endPattern = PathPatternOptions.EXTENSION.apply(extension);
+        return this;
+    }
+
+    /**
+     * Ensures the directory path starts with the specified {@code dirPath}.
+     * For example, `startsWith("/foo")` will match `/foo/test.zip`, `/foo/bar/test.zip`
+     * but not `/nix/foo/test.zip`.
+     *
+     * <p>This option can only be specified once; multiple declarations will override one another.
+     */
+    public PathPatternBuilder startsWith(String dirPath) {
+        requireNonNull(dirPath, "dirPath");
+        startPattern = PathPatternOptions.STARTS_WITH.apply(dirPath);
+        return this;
+    }
+
+    /**
+     * Ensures the directory path contains the specified {@code dirPath}.
+     * For example, `contains("/bar")` will match `/nix/bar/test.zip`, `/nix/quix/bar/twee/test.zip`
+     * but not `/bar/foo/test.zip` or `/ren/bar.json`.
+     *
+     * <p>This option can be specified multiple times; multiple declarations will be chained.
+     * For example, `contains("/bar").contains("foo")`
+     * creates the glob-like pattern string `&#47;**&#47;bar&#47;**&#47;foo&#47;**".
+     */
+    public PathPatternBuilder contains(String dirPath) {
+        requireNonNull(dirPath, "dirPath");
+        innerPatterns.add(PathPatternOptions.CONTAINS.apply(dirPath));
+        return this;
+    }
+
+    /**
+     * Compose one pathPattern from a list of {@code patterns}.
+     */
+    private static String combine(List<PathPattern> patterns) {
+        final StringBuilder sb = new StringBuilder();
+        for (final Iterator<PathPattern> i = patterns.iterator(); i.hasNext();) {
+            if (sb.length() == 0) {
+                // left should end with "/**"
+                sb.append(i.next().patternString());
+            } else {
+                // right should start with "/**/"
+                sb.append(i.next().patternString().substring(3));
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Returns a newly-created {@link PathPattern} based on the options of this builder.
+     */
+    public PathPattern build() {
+        final ImmutableList.Builder<PathPatternOption> optionsBuilder = ImmutableList.builder();
+        if (startPattern != null) {
+            optionsBuilder.add(startPattern);
+        }
+        optionsBuilder.addAll(innerPatterns);
+        if (endPattern != null) {
+            optionsBuilder.add(endPattern);
+        }
+        final ImmutableList<PathPatternOption> options = optionsBuilder.build();
+
+        checkState(!options.isEmpty(), "Requires at least one pattern to build in PathPatternBuilder");
+
+        if (options.size() == 1) {
+            return options.get(0).pathPattern();
+        }
+
+        final List<PathPattern> patterns = options.stream()
+                                                  .map(PathPatternOption::pathPattern)
+                                                  .collect(toImmutableList());
+        return new DefaultPathPattern(combine(patterns));
+    }
+}

common/src/main/java/com/linecorp/centraldogma/common/PathPatternOption.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2021 LINE Corporation
+ *
+ * LINE Corporation licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package com.linecorp.centraldogma.common;
+
+import java.util.function.Function;
+
+/**
+ * A {@link PathPatternBuilder} option.
+ */
+final class PathPatternOption {
+    private final String pattern;
+    /**
+     * Create {@link PathPattern} from {@code pattern}.
+     */
+    private final Function<String, PathPattern> pathPatternCreator;
+
+    PathPatternOption(String pattern,
+                      Function<String, PathPattern> pathPatternCreator) {
+        this.pattern = pattern;
+        this.pathPatternCreator = pathPatternCreator;
+    }
+
+    /**
+     * Returns the {@link PathPattern} of the option.
+     */
+    PathPattern pathPattern() {
+        return pathPatternCreator.apply(pattern);
+    }
+}