1533 move dependency and dependencies macros to core

buildSrc/src/main/groovy/io/micronaut/guides/GuideAsciidocGenerator.groovy

@@ -7,6 +7,7 @@ import io.micronaut.context.ApplicationContext
 import io.micronaut.core.annotation.NonNull
 import io.micronaut.core.util.StringUtils
 import io.micronaut.guides.core.App
+import io.micronaut.guides.core.DependencyLines
 import io.micronaut.guides.core.Guide
 import io.micronaut.guides.core.GuideUtils
 import io.micronaut.guides.core.GuidesOption

buildSrc/src/main/java/io/micronaut/guides/DependencyLines.java → buildSrc/src/main/java/io/micronaut/guides/core/DependencyLines.java

@@ -1,4 +1,4 @@
-package io.micronaut.guides;
+package io.micronaut.guides.core;
 
 import io.micronaut.core.util.StringUtils;
 import io.micronaut.starter.options.BuildTool;
@@ -28,22 +28,13 @@ private static String toMavenScope(Map<String, String> attributes) {
         if (s == null) {
             return null;
         }
-        switch (s) {
-            case "api":
-            case "implementation":
-            case "annotationProcessor":
-                return "compile";
-            case "testCompile":
-            case "testRuntimeOnly":
-            case "testImplementation":
-                return "test";
-            case "compileOnly":
-                return "provided";
-            case "runtimeOnly":
-                return "runtime";
-            default:
-                return s;
-        }
+        return switch (s) {
+            case "api", "implementation", "annotationProcessor" -> "compile";
+            case "testCompile", "testRuntimeOnly", "testImplementation" -> "test";
+            case "compileOnly" -> "provided";
+            case "runtimeOnly" -> "runtime";
+            default -> s;
+        };
     }
 
     private static String toGradleScope(Map<String, String> attributes, Language language) {
@@ -170,10 +161,10 @@ private static String extractCallout(Map<String, String> attributes) {
     }
 
     private static String getMavenAnnotationScopeXMLPath(Language language) {
-        switch (language) {
-            case JAVA: return "path";
-            case KOTLIN: return "annotationProcessorPath";
-            default: return ""; // not used for Groovy
-        }
+        return switch (language) {
+            case JAVA -> "path";
+            case KOTLIN -> "annotationProcessorPath";
+            default -> ""; // not used for Groovy
+        };
     }
 }

buildSrc/src/main/java/io/micronaut/guides/core/DependencyMacroSubstitution.java

@@ -0,0 +1,22 @@
+package io.micronaut.guides.core;
+
+import jakarta.inject.Singleton;
+import java.util.List;
+
+import static io.micronaut.guides.core.MacroUtils.*;
+
+@Singleton
+public class DependencyMacroSubstitution implements MacroSubstitution{
+    @Override
+    public String substitute(String str, String slug, GuidesOption option) {
+        for(String block : findMacroGroups(str, "dependencies")){
+            List<String> lines = DependencyLines.asciidoc(block.replace(":dependencies:","").strip().lines().toList(), option.getBuildTool(), option.getLanguage());
+            str = str.replace(block,String.join("\n", lines));
+        }
+        for(String line : findMacroLines(str, "dependency")){
+            List<String> lines = DependencyLines.asciidoc(line, option.getBuildTool(), option.getLanguage());
+            str = str.replace(line,String.join("\n", lines));
+        }
+        return str;
+    }
+}

buildSrc/src/main/java/io/micronaut/guides/core/MacroUtils.java

@@ -155,6 +155,27 @@ static List<String> findMacroLines(@NonNull String str, @NonNull String macro) {
                 .toList();
     }
 
+    static List<String> findMacroGroups(@NonNull String str, @NonNull String macro) {
+        List<String> matches = new ArrayList<>();
+        String pattern = ":"+macro+":";
+        int startIndex = 0;
+
+        while (true) {
+            startIndex = str.indexOf(pattern, startIndex);
+            if (startIndex == -1) break;
+
+            int endIndex = str.indexOf(pattern, startIndex + pattern.length());
+            if (endIndex == -1) break;
+
+            String match = str.substring(startIndex, endIndex + pattern.length());
+            matches.add(match);
+
+            startIndex = endIndex + pattern.length();
+        }
+
+        return matches;
+    }
+
     @NonNull
     static String resolveAsciidoctorLanguage(@NonNull String fileName) {
         String extension = fileName.indexOf(".") > 0 ?

buildSrc/src/main/java/io/micronaut/guides/core/TestResourceMacroSubstitution.java

@@ -0,0 +1,43 @@
+package io.micronaut.guides.core;
+
+import io.micronaut.core.annotation.NonNull;
+import jakarta.inject.Singleton;
+
+import java.util.List;
+
+import static io.micronaut.guides.core.MacroUtils.*;
+import static io.micronaut.guides.core.MacroUtils.addIncludes;
+
+@Singleton
+public class TestResourceMacroSubstitution implements MacroSubstitution {
+    private final GuidesConfiguration guidesConfiguration;
+    private final LicenseLoader licenseLoader;
+    public TestResourceMacroSubstitution(GuidesConfiguration guidesConfiguration, LicenseLoader licenseLoader) {
+        this.guidesConfiguration = guidesConfiguration;
+        this.licenseLoader = licenseLoader;
+    }
+
+    @Override
+    public String substitute(String str, String slug, GuidesOption option) {
+        for(String line : findMacroLines(str, "testResource")){
+
+            String name = extractName(line, "testResource");
+            String appName = extractAppName(line);
+            List<String> tags = extractTags(line);
+            String indent = extractIndent(line);
+            String sourcePath = testResourcePath(appName, name);
+            String extension = resolveAsciidoctorLanguage(name);
+
+            List<String> lines = addIncludes(option, licenseLoader, guidesConfiguration, slug, sourcePath, extension, indent, tags);
+
+            str = str.replace(line,String.join("\n", lines));
+        }
+        return str;
+    }
+
+    @NonNull
+    private static String testResourcePath(@NonNull String appName, @NonNull String fileName) {
+        String module = appName.isEmpty() ? "" : appName + "/";
+        return module + "src/" + "test/resources/" + fileName;
+    }
+}

buildSrc/src/main/java/io/micronaut/guides/core/asciidoc/IncludeDirective.java

@@ -156,7 +156,7 @@ private List<String> attributes() {
             if (getTags().size() > 1) {
                 attributes.add("tags=" + String.join(";",  getTags()));
             } else if (getTags().size() == 1) {
-                attributes.add("tag=" + getTags().getFirst());
+                attributes.add("tag=" + getTags().get(0));
             }
         }
         if (getIndent() != null) {

buildSrc/src/test/java/io/micronaut/guides/core/DependencyMacroSubstitutionTest.java

@@ -0,0 +1,70 @@
+package io.micronaut.guides.core;
+
+import io.micronaut.starter.api.TestFramework;
+import io.micronaut.starter.options.BuildTool;
+import io.micronaut.starter.options.Language;
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+@MicronautTest(startApplication = false)
+public class DependencyMacroSubstitutionTest {
+    @Inject
+    DependencyMacroSubstitution dependencyMacroSubstitution;
+
+    @Test
+    void testSubstitute(){
+        String str = """
+                ==== Dependencies
+
+                When you add a `jax-rs` feature, the generated application includes the following dependencies:
+
+                :dependencies:
+                dependency:micronaut-jaxrs-processor[groupId=io.micronaut.jaxrs,scope=annotationProcessor]
+                dependency:micronaut-jaxrs-server[groupId=io.micronaut.jaxrs]
+                :dependencies:
+
+                ==== Resource
+
+                :dependencies:
+                dependency:micronaut-flyway[groupId=io.micronaut.flyway]
+                :dependencies:
+
+                Test
+
+                dependency:micronaut-security-session[groupId=io.micronaut.security]
+                """;
+
+        String resJava = dependencyMacroSubstitution.substitute(str, "micronaut-jaxrs", new GuidesOption(BuildTool.GRADLE, Language.JAVA, TestFramework.SPOCK));
+        String expectedJava = """
+                ==== Dependencies
+
+                When you add a `jax-rs` feature, the generated application includes the following dependencies:
+
+                [source, groovy]
+                .build.gradle
+                ----
+                annotationProcessor("io.micronaut.jaxrs:micronaut-jaxrs-processor")
+                implementation("io.micronaut.jaxrs:micronaut-jaxrs-server")
+                ----
+
+                ==== Resource
+
+                [source, groovy]
+                .build.gradle
+                ----
+                implementation("io.micronaut.flyway:micronaut-flyway")
+                ----
+
+                Test
+
+                [source, groovy]
+                .build.gradle
+                ----
+                implementation("io.micronaut.security:micronaut-security-session")
+                ----
+                """;
+        assertEquals(expectedJava, resJava);
+    }
+}

buildSrc/src/test/java/io/micronaut/guides/core/MacroUtilsTest.java

@@ -106,4 +106,73 @@ void testAddIncludesWithoutTags() {
         assertEquals("include::{sourceDir}/exampleSlug/exampleSlug-gradle-java/exampleSourcePath[lines=16..-1;indent=4]", lines.get(3));
         assertEquals("----", lines.get(4));
     }
+
+    @Test
+    void testFindMacroGroups(){
+        String str = """
+                https://micronaut-projects.github.io/micronaut-validation/snapshot/guide/[Micronaut validation] is built on the standard framework – https://www.jcp.org/en/jsr/detail?id=380[JSR 380], also known as Bean Validation 2.0. Micronaut Validation has built-in support for validation of beans that are annotated with `jakarta.validation` annotations.
+
+                To use Micronaut Validation, you need the following dependencies:
+
+                :dependencies:
+
+                dependency:micronaut-validation-processor[groupId=io.micronaut.validation,scope=annotationProcessor]
+                dependency:micronaut-validation[groupId=io.micronaut.validation]
+
+                :dependencies:
+
+                Alternatively, you can use https://micronaut-projects.github.io/micronaut-hibernate-validator/latest/guide/[Micronaut Hibernate Validator], which uses https://hibernate.org/validator/[Hibernate Validator]; a reference implementation of the validation API.
+                """;
+        List<String> result = MacroUtils.findMacroGroups(str,"dependencies");
+        List<String> expected = List.of("""
+                :dependencies:
+
+                dependency:micronaut-validation-processor[groupId=io.micronaut.validation,scope=annotationProcessor]
+                dependency:micronaut-validation[groupId=io.micronaut.validation]
+
+                :dependencies:""");
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void testFindMacroGroupsMultiple(){
+        String str = """
+                https://micronaut-projects.github.io/micronaut-validation/snapshot/guide/[Micronaut validation] is built on the standard framework – https://www.jcp.org/en/jsr/detail?id=380[JSR 380], also known as Bean Validation 2.0. Micronaut Validation has built-in support for validation of beans that are annotated with `jakarta.validation` annotations.
+
+                To use Micronaut Validation, you need the following dependencies:
+
+                :dependencies:
+
+                dependency:micronaut-validation-processor[groupId=io.micronaut.validation,scope=annotationProcessor]
+                dependency:micronaut-validation[groupId=io.micronaut.validation]
+
+                :dependencies:
+
+                Alternatively, you can use https://micronaut-projects.github.io/micronaut-hibernate-validator/latest/guide/[Micronaut Hibernate Validator], which uses https://hibernate.org/validator/[Hibernate Validator]; a reference implementation of the validation API.
+
+                :dependencies:
+
+                dependency:geb-spock[groupId=org.gebish,scope=testImplementation,version=@geb-spockVersion@]
+                dependency:htmlunit-driver[groupId=org.seleniumhq.selenium,scope=testImplementation,version=@htmlunit-driverVersion@]
+
+                :dependencies:
+
+                Test
+                """;
+        List<String> result = MacroUtils.findMacroGroups(str,"dependencies");
+        List<String> expected = List.of("""
+                :dependencies:
+
+                dependency:micronaut-validation-processor[groupId=io.micronaut.validation,scope=annotationProcessor]
+                dependency:micronaut-validation[groupId=io.micronaut.validation]
+
+                :dependencies:""", """
+                :dependencies:
+
+                dependency:geb-spock[groupId=org.gebish,scope=testImplementation,version=@geb-spockVersion@]
+                dependency:htmlunit-driver[groupId=org.seleniumhq.selenium,scope=testImplementation,version=@htmlunit-driverVersion@]
+
+                :dependencies:""");
+        assertEquals(expected, result);
+    }
 }

buildSrc/src/test/java/io/micronaut/guides/core/TestResourceMacroSubstitutionTest.java

@@ -0,0 +1,30 @@
+package io.micronaut.guides.core;
+
+import io.micronaut.starter.api.TestFramework;
+import io.micronaut.starter.options.BuildTool;
+import io.micronaut.starter.options.Language;
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@MicronautTest(startApplication = false)
+public class TestResourceMacroSubstitutionTest {
+
+    @Inject
+    TestResourceMacroSubstitution testResourceMacroSubstitution;
+
+    @Test
+    void testSubstitute() {
+        String str = "testResource:application-test.yml[tag=testcontainers]";
+        String resJava = testResourceMacroSubstitution.substitute(str, "micronaut-metrics-oci", new GuidesOption(BuildTool.GRADLE, Language.JAVA, TestFramework.JUNIT));
+        String expectedJava = """
+                [source,yaml]
+                .src/test/resources/application-test.yml
+                ----
+                include::{sourceDir}/micronaut-metrics-oci/micronaut-metrics-oci-gradle-java/src/test/resources/application-test.yml[tag=testcontainers]
+                ----""";
+        assertEquals(expectedJava, resJava);
+    }
+}