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;
@@ -52,6 +53,12 @@ final class DefaultPathPattern implements PathPattern {
                                 }).collect(Collectors.joining(","));
     }
 
+    DefaultPathPattern(List<PathPattern> verifiedPatterns) {
+        patterns = verifiedPatterns.stream()
+                                   .map(PathPattern::patternString)
+                                   .collect(Collectors.joining(","));
+    }
+
     private DefaultPathPattern(String patterns, String encoded) {
         this.patterns = patterns;
         this.encoded = encoded;

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

@@ -19,6 +19,8 @@
 import static com.linecorp.centraldogma.common.DefaultPathPattern.allPattern;
 import static java.util.Objects.requireNonNull;
 
+import java.util.Arrays;
+
 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,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(Arrays.asList(pathPatterns));
+    }
+
     /**
      * Creates a path pattern with the {@code patterns}.
      */
@@ -62,6 +79,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,126 @@
+/*
+ * 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 java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.annotation.Nullable;
+
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * Builds a new {@link PathPattern}.
+ *
+ * <h2>Example</h2>
+ * <pre>{@code
+ * final PathPattern factory =
+ *         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;
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Combine 2 patterns into one.
+     */
+    private static String combine(String left, String right) {
+        checkArgument(left.endsWith("/**"), "left should end with \"/**\"");
+        checkArgument(right.startsWith("/**/"), "right should start with \"/**/\"");
+        return left + right.substring(3);
+    }
+
+    /**
+     * Compose one pathPattern from a list of {@code patterns}.
+     */
+    private static String combine(Iterable<PathPattern> patterns) {
+        final Iterator<PathPattern> iter = patterns.iterator();
+        String combinedPattern = iter.next().patternString();
+        while (iter.hasNext()) {
+            combinedPattern = combine(combinedPattern, iter.next().patternString());
+        }
+        return combinedPattern;
+    }
+
+    /**
+     * Returns a newly-created {@link PathPattern} based on the options of this builder.
+     */
+    public PathPattern build() {
+        final List<PathPatternOption> options = new ArrayList<>();
+        if (startPattern != null) {
+            options.add(startPattern);
+        }
+        options.addAll(innerPatterns);
+        if (endPattern != null) {
+            options.add(endPattern);
+        }
+
+        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(Collectors.toList());
+        return new DefaultPathPattern(ImmutableSet.of(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.
+ */
+public 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.
+     */
+    public PathPattern pathPattern() {
+        return pathPatternCreator.apply(pattern);
+    }
+}

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

@@ -0,0 +1,95 @@
+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.google.common.collect.ImmutableSet;
+
+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(ImmutableSet.of(
+                                              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");
+                                      return dirPath.endsWith("/") ? new DefaultPathPattern(
+                                              ImmutableSet.of("/**" + dirPath + "**"))
+                                                                   : new DefaultPathPattern(
+                                              ImmutableSet.of("/**" + 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");
+                                      return new DefaultPathPattern(ImmutableSet.of(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(
+                                                  ImmutableSet.of("/**/*" + extension));
+                                      } else { // need to add extension separator
+                                          return new DefaultPathPattern(
+                                                  ImmutableSet.of("/**/*." + 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