Merge branch 'main' into fix-adddependency-duplicate-applied-scripts

Author: timtebeek

.github/workflows/comment-pr.yml

@@ -22,3 +22,11 @@ allprojects {
     group = "org.openrewrite"
     description = "Eliminate tech-debt. Automatically."
 }
+
+// Use this task locally between different dependency check runs to have updated analysis:
+// OSSINDEX_PASSWORD=... OSSINDEX_USERNAME=... gradle cleanReports dCAg --no-parallel
+tasks.register<Delete>("cleanReports") {
+    description = "Removes build/reports folder from all modules"
+    group = "owasp dependency-check"
+    delete(allprojects.map { it.layout.buildDirectory.dir("reports") })
+}

.github/workflows/receive-pr.yml

@@ -449,12 +449,7 @@ public final RecipeRun run(LargeSourceSet before, ExecutionContext ctx, int maxC
 
     @SuppressWarnings("unused")
     public Validated<Object> validate(ExecutionContext ctx) {
-        Validated<Object> validated = validate();
-
-        for (Recipe recipe : getRecipeList()) {
-            validated = validated.and(recipe.validate(ctx));
-        }
-        return validated;
+        return validate();
     }
 
     /**
@@ -475,9 +470,6 @@ public Validated<Object> validate() {
                 validated = Validated.invalid(field.getName(), null, "Unable to access " + clazz.getName() + "." + field.getName(), e);
             }
         }
-        for (Recipe recipe : getRecipeList()) {
-            validated = validated.and(recipe.validate());
-        }
         return validated;
     }
 
@@ -561,6 +553,10 @@ public Recipe withOptions(@Nullable Map<String, Object> options) {
                         Map<String, Object> option = new HashMap<>();
                         option.put("value", value);
                         objectMapper.updateValue(optionDescriptor, option);
+
+                        if (optionDescriptor.getType().equals("List")) {
+                            m.put(optionDescriptor.getName(), Arrays.asList(((String) value).split(",")));
+                        }
                     }
                 }
             }

build.gradle.kts

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * 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
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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 org.openrewrite;
+
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.jspecify.annotations.Nullable;
+
+import java.net.URI;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+public class RecipeNotFoundException extends RuntimeException {
+    String recipeName;
+
+    @Nullable
+    URI source;
+
+    public RecipeNotFoundException(String recipeName) {
+        this(recipeName, null);
+    }
+
+    public RecipeNotFoundException(String recipeName, @Nullable URI source) {
+        super("Unable to find recipe " + recipeName + (source == null ? "" : " listed in " + source));
+        this.recipeName = recipeName;
+        this.source = source;
+    }
+}

rewrite-core/src/main/java/org/openrewrite/Recipe.java

@@ -374,10 +374,22 @@ public boolean isValid() {
 
         @Override
         public Iterator<Validated<T>> iterator() {
-            return Stream.concat(
-                    stream(left.spliterator(), false),
-                    stream(right.spliterator(), false)
-            ).iterator();
+            List<Validated<T>> result = new ArrayList<>();
+            Deque<Validated<T>> stack = new ArrayDeque<>();
+            stack.push(this);
+            while (!stack.isEmpty()) {
+                Validated<T> current = stack.pop();
+                if (current instanceof Both) {
+                    Both<T> both = (Both<T>) current;
+                    stack.push(both.right);
+                    stack.push(both.left);
+                } else {
+                    for (Validated<T> v : current) {
+                        result.add(v);
+                    }
+                }
+            }
+            return result.iterator();
         }
     }
 }

rewrite-core/src/main/java/org/openrewrite/RecipeNotFoundException.java

@@ -29,11 +29,17 @@
 import org.openrewrite.internal.RecipeLoader;
 import org.openrewrite.style.NamedStyles;
 
+import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
-import java.nio.file.Path;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
 import java.util.*;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
 
+import static java.nio.file.Files.*;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.emptyMap;
 
@@ -97,26 +103,73 @@ public ClasspathScanningLoader(Properties properties, ClassLoader classLoader) {
     /**
      * Construct a ClasspathScanningLoader as used from `Environment.scanJar` for
      * `MavenRecipeBundleReader.marketplaceFromClasspathScan`.
+     * Supports both jar files and directories containing class files.
      */
     public ClasspathScanningLoader(Path jar, Properties properties, Collection<? extends ResourceLoader> dependencyResourceLoaders, ClassLoader classLoader) {
         this.classLoader = classLoader;
         this.recipeLoader = new RecipeLoader(classLoader);
-        String jarName = jar.toFile().getName();
 
         this.performScan = () -> {
-            scanClasses(new ClassGraph()
+            Path jarPath;
+            if (isDirectory(jar)) {
+                try {
+                    jarPath = createTempJarFromDirectory(jar);
+                } catch (IOException e) {
+                    throw new UncheckedIOException("Failed to create temporary jar from directory: " + jar, e);
+                }
+            } else {
+                jarPath = jar;
+            }
+
+            String jarName = jarPath.toFile().getName();
+            ClassGraph classGraph = new ClassGraph()
+                    .overrideClasspath(jarPath.toString())
                     .acceptJars(jarName)
-                    .ignoreParentClassLoaders()
-                    .overrideClassLoaders(classLoader), classLoader);
+                    .overrideClassLoaders(classLoader);
 
-            scanYaml(new ClassGraph()
+            ClassGraph yamlGraph = new ClassGraph()
+                    .overrideClasspath(jarPath.toString())
                     .acceptJars(jarName)
-                    .ignoreParentClassLoaders()
                     .overrideClassLoaders(classLoader)
-                    .acceptPaths("META-INF/rewrite"), properties, dependencyResourceLoaders, classLoader);
+                    .acceptPaths("META-INF/rewrite");
+
+            scanClasses(classGraph, classLoader);
+            scanYaml(yamlGraph, properties, dependencyResourceLoaders, classLoader);
         };
     }
 
+    /**
+     * Creates a temporary jar file containing all files from the given directory.
+     */
+    private static Path createTempJarFromDirectory(Path directory) throws IOException {
+        Path tempJar = createTempFile("recipe-scan-", ".jar");
+        tempJar.toFile().deleteOnExit();
+
+        try (JarOutputStream jos = new JarOutputStream(newOutputStream(tempJar))) {
+            walkFileTree(directory, new SimpleFileVisitor<Path>() {
+                @Override
+                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+                    String entryName = directory.relativize(file).toString().replace('\\', '/');
+                    jos.putNextEntry(new JarEntry(entryName));
+                    copy(file, jos);
+                    jos.closeEntry();
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
+                    if (!dir.equals(directory)) {
+                        String entryName = directory.relativize(dir).toString().replace('\\', '/') + "/";
+                        jos.putNextEntry(new JarEntry(entryName));
+                        jos.closeEntry();
+                    }
+                    return FileVisitResult.CONTINUE;
+                }
+            });
+        }
+        return tempJar;
+    }
+
     /**
      * Construct a ClasspathScanningLoader to load Yaml categories and recipes from the runtime classpath, as part of
      * running tests or inferring local recipe categories.

rewrite-core/src/main/java/org/openrewrite/Validated.java

@@ -169,33 +169,47 @@ private void initializeDeclarativeRecipe(DeclarativeRecipe declarativeRecipe, St
     public Accumulator getInitialValue(ExecutionContext ctx) {
         Accumulator acc = new Accumulator();
         for (Recipe precondition : preconditions) {
-            if (precondition instanceof ScanningRecipe && isScanningRequired(precondition)) {
-                acc.recipeToAccumulator.put(precondition, ((ScanningRecipe<?>) precondition).getInitialValue(ctx));
-            }
+            registerNestedScanningRecipes(precondition, acc, ctx);
         }
         accumulator = acc;
         return acc;
     }
 
+    private void registerNestedScanningRecipes(Recipe recipe, Accumulator acc, ExecutionContext ctx) {
+        if (recipe instanceof ScanningRecipe && isScanningRequired(recipe)) {
+            acc.recipeToAccumulator.put(recipe, ((ScanningRecipe<?>) recipe).getInitialValue(ctx));
+        }
+        for (Recipe nested : recipe.getRecipeList()) {
+            registerNestedScanningRecipes(nested, acc, ctx);
+        }
+    }
+
     @Override
     public TreeVisitor<?, ExecutionContext> getScanner(Accumulator acc) {
         return new TreeVisitor<Tree, ExecutionContext>() {
             @SuppressWarnings({"rawtypes", "unchecked"})
             @Override
             public @Nullable Tree visit(@Nullable Tree tree, ExecutionContext ctx) {
                 for (Recipe precondition : preconditions) {
-                    if (precondition instanceof ScanningRecipe && isScanningRequired(precondition)) {
-                        ScanningRecipe preconditionRecipe = (ScanningRecipe) precondition;
-                        Object preconditionAcc = acc.recipeToAccumulator.get(precondition);
-                        preconditionRecipe.getScanner(preconditionAcc)
-                                .visit(tree, ctx);
-                    }
+                    scanNestedScanningRecipes(precondition, acc, tree, ctx);
                 }
                 return tree;
             }
         };
     }
 
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    private void scanNestedScanningRecipes(Recipe recipe, Accumulator acc, @Nullable Tree tree, ExecutionContext ctx) {
+        if (recipe instanceof ScanningRecipe && isScanningRequired(recipe)) {
+            ScanningRecipe scanningRecipe = (ScanningRecipe) recipe;
+            Object recipeAcc = acc.recipeToAccumulator.get(recipe);
+            scanningRecipe.getScanner(recipeAcc).visit(tree, ctx);
+        }
+        for (Recipe nested : recipe.getRecipeList()) {
+            scanNestedScanningRecipes(nested, acc, tree, ctx);
+        }
+    }
+
     public static class Accumulator {
         Map<Recipe, Object> recipeToAccumulator = new HashMap<>();
     }

rewrite-core/src/main/java/org/openrewrite/config/ClasspathScanningLoader.java

@@ -319,7 +319,7 @@ public Builder scanYamlResources() {
         }
 
         /**
-         * @param jar         A path to a jar file to scan.
+         * @param jar         A path to a jar file or directory containing class files to scan.
          * @param classLoader A classloader that is populated with the transitive dependencies of the jar.
          * @return This builder.
          */

rewrite-core/src/main/java/org/openrewrite/config/DeclarativeRecipe.java

@@ -98,7 +98,7 @@ public YamlResourceLoader(InputStream yamlInput, URI source, Properties properti
         this.recipeLoader = (recipeName, options) -> {
             RecipeListing listing = marketplace.findRecipe(recipeName);
             if (listing == null) {
-                throw new IllegalStateException("Unable to find recipe " + recipeName + " listed in " + source);
+                throw new RecipeNotFoundException(recipeName, source);
             }
             return listing.prepare(resolvers, options == null ? emptyMap() : options);
         };
@@ -356,6 +356,12 @@ void loadRecipe(@Language("markdown") String name,
             } catch (IllegalArgumentException ignored) {
                 // it's probably declarative
                 addLazyLoadRecipe.accept(recipeName);
+            } catch (RecipeNotFoundException e) {
+                addInvalidRecipeValidation(
+                        addValidation,
+                        recipeName,
+                        null,
+                        e.getMessage());
             } catch (NoClassDefFoundError e) {
                 addInvalidRecipeValidation(
                         addValidation,
@@ -385,6 +391,12 @@ void loadRecipe(@Language("markdown") String name,
                                     recipeArgs,
                                     "Unable to load Recipe: " + e);
                         }
+                    } catch (RecipeNotFoundException e) {
+                        addInvalidRecipeValidation(
+                                addValidation,
+                                recipeName,
+                                recipeArgs,
+                                e.getMessage());
                     } catch (NoClassDefFoundError e) {
                         addInvalidRecipeValidation(
                                 addValidation,
@@ -404,7 +416,7 @@ void loadRecipe(@Language("markdown") String name,
                         addValidation,
                         recipeName,
                         recipeArgs,
-                        "Unexpected declarative recipe parsing exception " + e.getClass().getName());
+                        "Unexpected declarative recipe parsing exception " + e.getClass().getName() + ": " + e.getMessage());
             }
         } else {
             addValidation.accept(invalid(