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

@@ -19,6 +19,7 @@
 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 +37,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 +58,14 @@ 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) {
+        requireNonNull(pathPatterns, "pathPatterns");
+        return new DefaultPathPattern(ImmutableList.copyOf(pathPatterns));
+    }
+
     /**
      * Creates a path pattern with the {@code patterns}.
      */
@@ -62,6 +78,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 extension(String extension) {
+        return builder().extension(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,125 @@
+/*
+ * 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.checkArgument;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+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")
+ *                    .extension("json")
+ *                    .build();
+ * }</pre>
+ */
+public final class PathPatternBuilder {
+    @Nullable
+    private PathPatternOption startPattern;
+    private final List<PathPatternOption> innerPatterns = new ArrayList<>();
+    @Nullable
+    private PathPatternOption endPattern;
+
+    PathPatternBuilder() {}
+
+    /**
+     * Adds {@link PathPatternOptions#ENDS_WITH}.
+     */
+    public PathPatternBuilder endsWith(String filename) {
+        endPattern = PathPatternOptions.ENDS_WITH.apply(filename);
+        return this;
+    }
+
+    /**
+     * Adds {@link PathPatternOptions#EXTENSION}.
+     */
+    public PathPatternBuilder extension(String extension) {
+        endPattern = PathPatternOptions.EXTENSION.apply(extension);
+        return this;
+    }
+
+    /**
+     * Adds {@link PathPatternOptions#STARTS_WITH}.
+     */
+    public PathPatternBuilder startsWith(String dirPath) {
+        startPattern = PathPatternOptions.STARTS_WITH.apply(dirPath);
+        return this;
+    }
+
+    /**
+     * Adds {@link PathPatternOptions#CONTAINS}.
+     */
+    public PathPatternBuilder contains(String 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();
+
+        checkArgument(!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);
+    }
+}

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

@@ -0,0 +1,93 @@
+package com.linecorp.centraldogma.common;
+
+/*
+ * 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.
+ */
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import java.util.function.Function;
+import java.util.regex.Pattern;
+
+import com.linecorp.centraldogma.internal.Util;
+
+/**
+ * A set of {@link PathPatternOption}s.
+ */
+final class PathPatternOptions {
+
+    private static final Pattern FILE_EXTENSION_PATTERN = Pattern.compile("^.{0,1}[0-9a-z]+$");
+
+    private PathPatternOptions() {}
+
+    /**
+     * Appends "/**" to {@code dirPath}.
+     * Returns the path pattern for matching all file(s) under {@code dirPath}.
+     */
+    public static final Function<String, PathPatternOption> STARTS_WITH = pattern ->
+            new PathPatternOption(pattern,
+                                  dirPath -> {
+                                      checkArgument(Util.isValidDirPath(dirPath), "dir");
+                                      return new DefaultPathPattern(
+                                              dirPath + (dirPath.endsWith("/") ? "" : "/") + "**");
+                                  });
+
+    /**
+     * Prepends and appends "&#47;**" to target {@code dirPath}.
+     * Returns the path pattern for matching all file(s) containing {@code dirPath}.
+     */
+    public static final Function<String, PathPatternOption> CONTAINS = pattern ->
+            new PathPatternOption(pattern,
+                                  dirPath -> {
+                                      checkArgument(Util.isValidDirPath(dirPath), "dirPath");
+                                      if (dirPath.endsWith("/")) {
+                                          return new DefaultPathPattern("/**" + dirPath + "**");
+                                      } else { // add ending slash to dirPath
+                                          return new DefaultPathPattern("/**" + dirPath + "/**");
+                                      }
+                                  });
+
+    /**
+     * Prepends "&#47;**&#47;" to {@code filename}.
+     * Returns the path pattern for matching file(s) ending in {@code filename}.
+     */
+    public static final Function<String, PathPatternOption> ENDS_WITH = pattern ->
+            new PathPatternOption(pattern,
+                                  filename -> {
+                                      checkArgument(Util.isValidFileName(filename), "filename");
+                                      // `/**` is added by the constructor of `DefaultPathPattern`
+                                      return new DefaultPathPattern(filename);
+                                  });
+
+    /**
+     * Prepends "&#47;**&#47;*" to {@code extension}.
+     * Returns the path pattern for matching file(s) ending in {@code extension}.
+     */
+    public static final Function<String, PathPatternOption> EXTENSION = pattern ->
+            new PathPatternOption(pattern,
+                                  extension -> {
+                                      checkArgument(isValidFileExtension(extension), "extension");
+                                      if (extension.startsWith(".")) {
+                                          return new DefaultPathPattern("/**/*" + extension);
+                                      } else { // add extension separator
+                                          return new DefaultPathPattern("/**/*." + extension);
+                                      }
+                                  });
+
+    private static boolean isValidFileExtension(String extension) {
+        checkArgument(!extension.isEmpty(), "extension");
+        return FILE_EXTENSION_PATTERN.matcher(extension).matches();
+    }
+}

common/src/test/java/com/linecorp/centraldogma/common/DefaultPathPatternTest.java

@@ -38,6 +38,11 @@ void pathPattern() {
         pathPattern = PathPattern.of(ImmutableSet.of("/foo/*.json", "/*/foo.txt", "/**"));
         assertThat(pathPattern.patternString()).isEqualTo("/**");
         assertThat(pathPattern.encoded()).isEqualTo("/**");
+
+        pathPattern = PathPattern.of(PathPattern.of("*.json"),
+                                     PathPattern.startsWith("/foo/bar"));
+        assertThat(pathPattern.patternString()).isEqualTo("/**/*.json,/foo/bar/**");
+        assertThat(pathPattern.encoded()).isEqualTo("/**/*.json,/foo/bar/**");
     }
 
     @Test