Merge pull request #496 from jonesbusy/feature/cleanup-collector

MetadataCollector is not anymore a scanning recipe and various cleanup

Author: jonesbusy

plugin-modernizer-cli/src/test/resources/logback-test.xml

@@ -14,11 +14,13 @@
     <root level="TRACE">
         <appender-ref ref="CONSOLE" />
     </root>
+    <logger name="io.micrometer.common.util.internal.logging" level="INFO" />
     <logger name="io.jenkins.tools.pluginmodernizer" level="TRACE" />
     <logger name="io.jenkins.tools.pluginmodernizer.cli.utils" level="INFO" />
+    <logger name="org.apache.sshd.common.util" level="WARN" />
     <logger name="org.testcontainers" level="INFO" />
     <logger name="com.github.sparsick.testcontainers" level="INFO" />
-    <logger name="tc.rockstorm/git-server:2.45" level="WARN" />
+    <logger name="tc.rockstorm/git-server:2.47" level="WARN" />
     <logger name="tc.testcontainers/ryuk:0.9.0" level="WARN" />
     <logger name="com.github.dockerjava" level="INFO" />
 </configuration>

plugin-modernizer-core/src/main/java/io/jenkins/tools/pluginmodernizer/core/extractor/JenkinsfileVisitor.java

@@ -0,0 +1,106 @@
+package io.jenkins.tools.pluginmodernizer.core.extractor;
+
+import io.jenkins.tools.pluginmodernizer.core.model.JDK;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+import org.openrewrite.groovy.GroovyIsoVisitor;
+import org.openrewrite.groovy.tree.G;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Visitor for a Jenkinsfile
+ */
+public class JenkinsfileVisitor extends GroovyIsoVisitor<PluginMetadata> {
+
+    /**
+     * LOGGER.
+     */
+    public static final Logger LOG = LoggerFactory.getLogger(JenkinsfileVisitor.class);
+
+    private final Map<String, Object> variableMap = new HashMap<>();
+
+    @Override
+    public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations v, PluginMetadata pluginMetadata) {
+        LOG.debug("Visiting variable declarations {}", v);
+        J.VariableDeclarations variableDeclarations = super.visitVariableDeclarations(v, pluginMetadata);
+
+        for (J.VariableDeclarations.NamedVariable variable : variableDeclarations.getVariables()) {
+            variableMap.put(variable.getSimpleName(), variable.getInitializer());
+        }
+
+        return variableDeclarations;
+    }
+
+    @Override
+    public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, PluginMetadata pluginMetadata) {
+        LOG.debug("Visiting method invocation {}", method);
+        method = super.visitMethodInvocation(method, pluginMetadata);
+        if ("buildPlugin".equals(method.getSimpleName())) {
+            List<Expression> args = method.getArguments();
+
+            List<Integer> jdkVersions =
+                    args.stream().flatMap(this::extractJdkVersions).distinct().toList();
+
+            LOG.info("JDK versions found: {}", jdkVersions);
+
+            jdkVersions.forEach(jdkVersion -> pluginMetadata.addJdk(JDK.get(jdkVersion)));
+        }
+
+        return method;
+    }
+
+    private Stream<Integer> extractJdkVersions(Expression arg) {
+        if (arg instanceof G.MapEntry) {
+            return Stream.of(arg)
+                    .map(G.MapEntry.class::cast)
+                    .filter(entry -> "configurations".equals(((J.Literal) entry.getKey()).getValue()))
+                    .map(entry -> resolveConfigurations(entry.getValue()))
+                    .filter(value -> value instanceof G.ListLiteral)
+                    .flatMap(value -> ((G.ListLiteral) value).getElements().stream())
+                    .filter(expression -> expression instanceof G.MapLiteral)
+                    .flatMap(expression -> ((G.MapLiteral) expression).getElements().stream())
+                    .filter(mapExpr -> mapExpr instanceof G.MapEntry)
+                    .map(G.MapEntry.class::cast)
+                    .filter(mapEntry -> "jdk".equals(((J.Literal) mapEntry.getKey()).getValue()))
+                    .map(mapEntry -> Integer.parseInt(
+                            ((J.Literal) mapEntry.getValue()).getValue().toString()));
+        } else {
+            Expression resolvedArg = resolveVariable(arg);
+            return Stream.of(resolvedArg)
+                    .filter(resolved -> resolved instanceof G.MapLiteral)
+                    .flatMap(resolved -> ((G.MapLiteral) resolved).getElements().stream())
+                    .filter(entry -> entry instanceof G.MapEntry)
+                    .map(G.MapEntry.class::cast)
+                    .filter(entry -> "configurations".equals(((J.Literal) entry.getKey()).getValue()))
+                    .map(entry -> resolveConfigurations(entry.getValue()))
+                    .filter(value -> value instanceof G.ListLiteral)
+                    .flatMap(value -> ((G.ListLiteral) value).getElements().stream())
+                    .filter(expression -> expression instanceof G.MapLiteral)
+                    .flatMap(expression -> ((G.MapLiteral) expression).getElements().stream())
+                    .filter(mapExpr -> mapExpr instanceof G.MapEntry)
+                    .map(G.MapEntry.class::cast)
+                    .filter(mapEntry -> "jdk".equals(((J.Literal) mapEntry.getKey()).getValue()))
+                    .map(mapEntry -> Integer.parseInt(
+                            ((J.Literal) mapEntry.getValue()).getValue().toString()));
+        }
+    }
+
+    private Expression resolveVariable(Expression expression) {
+        if (expression instanceof J.Identifier) {
+            String variableName = ((J.Identifier) expression).getSimpleName();
+            if (variableMap.containsKey(variableName)) {
+                return (Expression) variableMap.get(variableName);
+            }
+        }
+        return expression;
+    }
+
+    private Expression resolveConfigurations(Expression entry) {
+        return entry instanceof G.ListLiteral ? entry : resolveVariable(entry);
+    }
+}