stager-maven-plugin: list-files task

Author: romain-grecourt

common/common/src/main/java/io/helidon/build/common/Patterns.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 Oracle and/or its affiliates.
+ *
+ * Licensed 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
+ *
+ *     http://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 io.helidon.build.common;
+
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * {@link Pattern} utility.
+ */
+public final class Patterns {
+
+    private static final Pattern NAMED_GROUP_PATTERN = Pattern.compile("\\(\\?<([^!=].*?)>");
+
+    private Patterns() {
+        // cannot be instanciated
+    }
+
+    /**
+     * Get the group names defined in a regular expression.
+     *
+     * @param regex regular expression
+     * @return group names
+     */
+    public static Set<String> groupNames(String regex) {
+        return NAMED_GROUP_PATTERN.matcher(regex)
+                .results()
+                .map(r -> r.group(1))
+                .collect(Collectors.toSet());
+    }
+}

common/common/src/main/java/io/helidon/build/common/SourcePath.java

@@ -31,6 +31,8 @@
 import java.util.Objects;
 import java.util.stream.Collectors;
 
+import static io.helidon.build.common.Strings.normalizePath;
+
 /**
  * Utility class to parse and match path segments.
  */
@@ -62,7 +64,16 @@ public SourcePath(File dir, File file) {
      * @param file the filed contained in the directory
      */
     public SourcePath(Path dir, Path file) {
-        segments = parseSegments(getRelativePath(dir, file));
+        this(dir.relativize(file));
+    }
+
+    /**
+     * Create a new {@link SourcePath} instance for the given path.
+     *
+     * @param path the path to use
+     */
+    public SourcePath(Path path) {
+        this(normalizePath(path));
     }
 
     /**
@@ -95,10 +106,6 @@ public SourcePath(List<String> paths) {
                 .toArray(String[]::new);
     }
 
-    private static String getRelativePath(Path sourceDir, Path source) {
-        return Strings.normalizePath(sourceDir.relativize(source));
-    }
-
     /**
      * Parse a {@code '/'} separated path into segments. Collapses empty or {@code '.'} only segments.
      *

maven-plugins/stager-maven-plugin/pom.xml

@@ -31,6 +31,7 @@
     <packaging>maven-plugin</packaging>
 
     <properties>
+        <maven.compiler.release>17</maven.compiler.release>
         <spotbugs.exclude>etc/spotbugs/exclude.xml</spotbugs.exclude>
     </properties>
 

maven-plugins/stager-maven-plugin/src/it/projects/file/pom.xml

@@ -1,6 +1,6 @@
 <!--
 
-    Copyright (c) 2020, 2022 Oracle and/or its affiliates.
+    Copyright (c) 2020, 2023 Oracle and/or its affiliates.
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -43,6 +43,24 @@
                                 <files>
                                     <file target="CNAME">${cname}</file>
                                     <file target="cli-data/latest">${cli.data.latest.version}</file>
+                                    <file target="docs/v4/index.html"/>
+                                    <file target="docs/v4/apidocs/index.html"/>
+                                    <file target="docs/v4/images/foo.svg"/>
+                                    <file target="sitemap.txt">
+                                        <list-files dir=".">
+                                            <includes>
+                                                <include>**/docs/**</include>
+                                            </includes>
+                                            <excludes>
+                                                <exclude>**/images/**</exclude>
+                                            </excludes>
+                                            <substitutions>
+                                                <substitution
+                                                        match="^(?&lt;path&gt;([^/]+/)*)index.html$"
+                                                        replace="{path}" />
+                                            </substitutions>
+                                        </list-files>
+                                    </file>
                                 </files>
                             </directory>
                         </directories>

maven-plugins/stager-maven-plugin/src/main/java/io/helidon/build/maven/stager/ConfigReader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,10 +16,10 @@
 package io.helidon.build.maven.stager;
 
 import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -62,28 +62,26 @@ public void visitNode(PlexusConfigNode node) {
 
     @Override
     public void postVisitNode(PlexusConfigNode node) {
-        PlexusConfigNode nodeParent = node.parent();
-        String nodeName = node.name();
+        PlexusConfigNode parent = node.parent();
+        String name = node.name();
         mappings.computeIfAbsent(node, n -> new LinkedHashMap<>());
-        mappings.computeIfAbsent(nodeParent, n -> new LinkedHashMap<>());
+        mappings.computeIfAbsent(parent, n -> new LinkedHashMap<>());
         Scope scope = scopes.peek();
         if (scope == null) {
             throw new IllegalStateException("Scope is not available");
         }
-        StagingElement element = factory.create(
-                nodeName,
-                node.attributes(),
-                mappings.get(node),
-                node.value(),
-                scope);
-        if (element instanceof Variables) {
-            for (Variable variable : ((Variables) element)) {
+        StagingElement element = factory.create(name, node.attributes(), mappings.get(node), node.value(), scope);
+        if (element instanceof Variables variables) {
+            for (Variable variable : variables) {
                 scope.parent.variables.put(variable.name(), variable);
             }
         }
-        mappings.get(nodeParent)
-                .computeIfAbsent(nodeName, n -> new LinkedList<>())
-                .add(element);
+        List<StagingElement> siblings = mappings.get(parent).computeIfAbsent(name, n -> new ArrayList<>());
+        if (element instanceof StagingElements elements) {
+            siblings.addAll(elements.nested());
+        } else {
+            siblings.add(element);
+        }
         scopes.pop();
     }
 

maven-plugins/stager-maven-plugin/src/main/java/io/helidon/build/maven/stager/Exclude.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Oracle and/or its affiliates.
+ *
+ * Licensed 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
+ *
+ *     http://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 io.helidon.build.maven.stager;
+
+/**
+ * Exclude.
+ */
+record Exclude(String value) implements StagingElement {
+
+    static final String ELEMENT_NAME = "exclude";
+
+    @Override
+    public String elementName() {
+        return ELEMENT_NAME;
+    }
+}

maven-plugins/stager-maven-plugin/src/main/java/io/helidon/build/maven/stager/FileTask.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2022 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2023 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,11 @@
  */
 package io.helidon.build.maven.stager;
 
+import java.io.BufferedWriter;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -30,8 +32,8 @@ final class FileTask extends StagingTask {
     private final String content;
     private final String source;
 
-    FileTask(ActionIterators iterators, Map<String, String> attrs, String content) {
-        super(ELEMENT_NAME, null, iterators, attrs);
+    FileTask(ActionIterators iterators, List<TextAction> nested, Map<String, String> attrs, String content) {
+        super(ELEMENT_NAME, nested, iterators, attrs);
         this.content = content;
         this.source = attrs.get("source");
     }
@@ -50,10 +52,16 @@ String source() {
      *
      * @return content, may be {@code null}
      */
-    public String content() {
+    String content() {
         return content;
     }
 
+    @Override
+    @SuppressWarnings("unchecked")
+    List<TextAction> tasks() {
+        return (List<TextAction>) super.tasks();
+    }
+
     @Override
     protected void doExecute(StagingContext ctx, Path dir, Map<String, String> vars) throws IOException {
         String resolvedTarget = resolveVar(target(), vars);
@@ -72,6 +80,12 @@ protected void doExecute(StagingContext ctx, Path dir, Map<String, String> vars)
             Files.createFile(targetFile);
             if (resolvedContent != null && !resolvedContent.isEmpty()) {
                 Files.writeString(targetFile, resolvedContent);
+            } else {
+                try (BufferedWriter writer = Files.newBufferedWriter(targetFile)) {
+                    for (TextAction task : tasks()) {
+                        writer.write(task.text());
+                    }
+                }
             }
         }
     }

maven-plugins/stager-maven-plugin/src/main/java/io/helidon/build/maven/stager/Include.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Oracle and/or its affiliates.
+ *
+ * Licensed 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
+ *
+ *     http://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 io.helidon.build.maven.stager;
+
+/**
+ * Include.
+ */
+record Include(String value) implements StagingElement {
+
+    static final String ELEMENT_NAME = "include";
+
+    @Override
+    public String elementName() {
+        return ELEMENT_NAME;
+    }
+}

maven-plugins/stager-maven-plugin/src/main/java/io/helidon/build/maven/stager/ListFilesTask.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2023 Oracle and/or its affiliates.
+ *
+ * Licensed 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
+ *
+ *     http://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 io.helidon.build.maven.stager;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+import io.helidon.build.common.Lists;
+import io.helidon.build.common.SourcePath;
+
+import static io.helidon.build.common.FileUtils.walk;
+import static io.helidon.build.common.Strings.normalizePath;
+
+/**
+ * List files in a directory.
+ */
+final class ListFilesTask extends StagingTask implements TextAction {
+
+    static final String ELEMENT_NAME = "list-files";
+
+    private final List<String> includes;
+    private final List<String> excludes;
+    private final List<Substitution> substitutions;
+    private final List<BiFunction<String, Map<String, String>, String>> chain;
+    private final String dirName;
+    private final StringBuilder buf = new StringBuilder();
+
+    ListFilesTask(ActionIterators iterators,
+                  List<Include> includes,
+                  List<Exclude> excludes,
+                  List<Substitution> substitutions,
+                  Map<String, String> attrs) {
+
+        super(ELEMENT_NAME, null, iterators, attrs);
+        this.includes = Lists.map(includes, Include::value);
+        this.excludes = Lists.map(excludes, Exclude::value);
+        this.substitutions = substitutions;
+        this.chain = Lists.map(substitutions, Substitution::function);
+        this.dirName = attrs.getOrDefault("dir", ".");
+    }
+
+    @Override
+    public String text() {
+        return buf.toString();
+    }
+
+    List<String> includes() {
+        return includes;
+    }
+
+    List<String> excludes() {
+        return excludes;
+    }
+
+    List<Substitution> substitutions() {
+        return substitutions;
+    }
+
+    @Override
+    protected void doExecute(StagingContext ctx, Path dir, Map<String, String> vars) {
+        Path resolved = dir.resolve(dirName);
+        List<Path> files = walk(resolved, (p, a) -> p.equals(resolved) || new SourcePath(p).matches(includes, excludes));
+        for (Path file : files) {
+            String entry = normalizePath(dir.relativize(file));
+            for (var function : chain) {
+                entry = function.apply(entry, vars);
+            }
+            buf.append(entry).append("\n");
+        }
+    }
+}