Merge branch 'main' into fix/change-type-source-path

Author: KaushikV1017

rewrite-core/build.gradle.kts

@@ -46,5 +46,5 @@ tasks.withType<Javadoc> {
     //   symbol:   method onConstructor_()
     //   location: @interface AllArgsConstructor
     // 1 error
-    exclude("**/RpcObjectData.java")
+    exclude("**/RpcObjectData.java", "**/RecipeDescriptor.java")
 }

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

@@ -25,6 +25,7 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.UncheckedIOException;
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -83,6 +84,10 @@ public static Checksum fromUri(HttpSender httpSender, URI uri, String algorithm)
                 .withMethod(HttpSender.Method.GET)
                 .build();
         try (HttpSender.Response response = httpSender.send(request)) {
+            if (!response.isSuccessful()) {
+                throw new UncheckedIOException(new IOException(
+                        "Failed to download checksum from " + uri + ": HTTP " + response.getCode()));
+            }
             String hexString = new String(response.getBodyAsBytes(), StandardCharsets.UTF_8);
             return Checksum.fromHex(algorithm, hexString);
         }

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

@@ -99,4 +99,17 @@ default void afterCycle(boolean lastCycle) {
      */
     @Nullable
     SourceFile getBefore(Path sourcePath);
+
+    /**
+     * Called when a recipe's {@code generate()} produces a file whose path collides with
+     * an existing source file or with another generated file. The generated file is silently
+     * dropped. Implementations may override this to detect the collision (e.g. the test
+     * framework raises an assertion failure).
+     *
+     * @param sourcePath    The colliding source path.
+     * @param existingFile  {@code true} if the collision is with an existing source file,
+     *                      {@code false} if it's with another generated file.
+     */
+    default void onGenerateCollision(Path sourcePath, boolean existingFile) {
+    }
 }

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

@@ -203,8 +203,6 @@ public String getInstanceNameSuffix() {
      * A set of strings used for categorizing related recipes. For example
      * "testing", "junit", "spring". Any individual tag should consist of a
      * single word, all lowercase.
-     *
-     * @return The tags.
      */
     @Getter
     final Set<String> tags = emptySet();
@@ -225,11 +223,21 @@ public final RecipeDescriptor getDescriptor() {
 
     protected RecipeDescriptor createRecipeDescriptor() {
         List<OptionDescriptor> options = getOptionDescriptors();
-        ArrayList<RecipeDescriptor> recipeList1 = new ArrayList<>();
-        for (Recipe next : getRecipeList()) {
-            recipeList1.add(next.getDescriptor());
+        List<RecipeDescriptor> preconditionDescriptors = emptyList();
+        if (this instanceof RecipePreconditions) {
+            RecipePreconditions recipeWithPreconditions = (RecipePreconditions) this;
+            List<Recipe> preconditions = recipeWithPreconditions.getPreconditions();
+            preconditionDescriptors = new ArrayList<>(preconditions.size());
+            for (Recipe precondition : preconditions) {
+                preconditionDescriptors.add(precondition.getDescriptor());
+            }
+        }
+
+        List<Recipe> recipeList = getRecipeList();
+        List<RecipeDescriptor> recipeDescriptors = new ArrayList<>(recipeList.size());
+        for (Recipe next : recipeList) {
+            recipeDescriptors.add(next.getDescriptor());
         }
-        recipeList1.trimToSize();
 
         URI recipeSource;
         try {
@@ -239,7 +247,7 @@ protected RecipeDescriptor createRecipeDescriptor() {
         }
 
         return new RecipeDescriptor(getName(), getDisplayName(), getInstanceName(), getDescription(), getTags(),
-                getEstimatedEffortPerOccurrence(), options, recipeList1, getDataTableDescriptors(),
+                getEstimatedEffortPerOccurrence(), options, preconditionDescriptors, recipeDescriptors, getDataTableDescriptors(),
                 getMaintainers(), getContributors(), getExamples(), recipeSource);
     }
 

rewrite-core/src/main/java/org/openrewrite/config/ClasspathScanningLoader.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/config/DeclarativeRecipe.java

@@ -32,7 +32,7 @@
 import static org.openrewrite.Validated.invalid;
 
 @RequiredArgsConstructor
-public class DeclarativeRecipe extends ScanningRecipe<DeclarativeRecipe.Accumulator> {
+public class DeclarativeRecipe extends ScanningRecipe<DeclarativeRecipe.Accumulator> implements RecipePreconditions {
     @Getter
     private final String name;
 
@@ -187,7 +187,6 @@ private void registerNestedScanningRecipes(Recipe recipe, Accumulator acc, Execu
     @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) {
@@ -251,7 +250,7 @@ public boolean isAcceptable(SourceFile sourceFile, ExecutionContext ctx) {
 
     @EqualsAndHashCode(callSuper = false)
     @Value
-    static class BellwetherDecoratedRecipe extends Recipe implements DelegatingRecipe {
+    static class BellwetherDecoratedRecipe extends Recipe implements DelegatingRecipe, RecipePreconditions {
 
         DeclarativeRecipe.PreconditionBellwether bellwether;
         Recipe delegate;
@@ -350,11 +349,19 @@ public Validated<Object> validate(ExecutionContext ctx) {
         public Collection<Validated<Object>> validateAll(ExecutionContext ctx, Collection<Validated<Object>> acc) {
             return delegate.validateAll(ctx, acc);
         }
+
+        @Override
+        public List<Recipe> getPreconditions() {
+            if (delegate instanceof RecipePreconditions) {
+                return ((RecipePreconditions) delegate).getPreconditions();
+            }
+            return emptyList();
+        }
     }
 
     @Value
     @EqualsAndHashCode(callSuper = false)
-    static class BellwetherDecoratedScanningRecipe<T> extends ScanningRecipe<T> implements DelegatingRecipe {
+    static class BellwetherDecoratedScanningRecipe<T> extends ScanningRecipe<T> implements DelegatingRecipe, RecipePreconditions {
 
         DeclarativeRecipe.PreconditionBellwether bellwether;
         ScanningRecipe<T> delegate;
@@ -468,6 +475,14 @@ public Validated<Object> validate(ExecutionContext ctx) {
         public Collection<Validated<Object>> validateAll(ExecutionContext ctx, Collection<Validated<Object>> acc) {
             return delegate.validateAll(ctx, acc);
         }
+
+        @Override
+        public List<Recipe> getPreconditions() {
+            if (delegate instanceof RecipePreconditions) {
+                return ((RecipePreconditions) delegate).getPreconditions();
+            }
+            return emptyList();
+        }
     }
 
     @Override
@@ -589,13 +604,17 @@ private static class LazyLoadedRecipe extends Recipe {
 
     @Override
     protected RecipeDescriptor createRecipeDescriptor() {
-        List<RecipeDescriptor> recipeList = new ArrayList<>();
-        for (Recipe childRecipe : getRecipeList()) {
-            recipeList.add(childRecipe.getDescriptor());
+        List<RecipeDescriptor> preconditionDescriptors = new ArrayList<>();
+        for (Recipe childRecipe : preconditions) {
+            preconditionDescriptors.add(childRecipe.getDescriptor());
+        }
+        List<RecipeDescriptor> recipeDescriptors = new ArrayList<>();
+        for (Recipe childRecipe : recipeList) {
+            recipeDescriptors.add(childRecipe.getDescriptor());
         }
         return new RecipeDescriptor(getName(), getDisplayName(), getInstanceName(), getDescription() != null ? getDescription() : "",
                 getTags(), getEstimatedEffortPerOccurrence(),
-                emptyList(), recipeList, getDataTableDescriptors(), getMaintainers(), getContributors(),
+                emptyList(), preconditionDescriptors, recipeDescriptors, getDataTableDescriptors(), getMaintainers(), getContributors(),
                 getExamples(), source);
     }
 

rewrite-core/src/main/java/org/openrewrite/config/Environment.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/RecipeDescriptor.java

@@ -15,6 +15,8 @@
  */
 package org.openrewrite.config;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
+import lombok.AllArgsConstructor;
 import lombok.EqualsAndHashCode;
 import lombok.Value;
 import lombok.With;
@@ -36,6 +38,7 @@
 
 @Value
 @EqualsAndHashCode(onlyExplicitlyIncluded = true)
+@AllArgsConstructor(onConstructor = @__(@JsonCreator))
 public class RecipeDescriptor {
     @EqualsAndHashCode.Include
     String name;
@@ -57,6 +60,9 @@ public class RecipeDescriptor {
     @EqualsAndHashCode.Include
     List<OptionDescriptor> options;
 
+    @With
+    List<RecipeDescriptor> preconditions;
+
     @With
     List<RecipeDescriptor> recipeList;
 
@@ -73,6 +79,16 @@ public class RecipeDescriptor {
     @Deprecated
     URI source;
 
+    @Deprecated
+    public RecipeDescriptor(String name, String displayName, String instanceName, String description,
+                            Set<String> tags, @Nullable Duration estimatedEffortPerOccurrence,
+                            List<OptionDescriptor> options, List<RecipeDescriptor> recipeList,
+                            List<DataTableDescriptor> dataTables, List<Maintainer> maintainers,
+                            List<Contributor> contributors, List<RecipeExample> examples, URI source) {
+        this(name, displayName, instanceName, description, tags, estimatedEffortPerOccurrence,
+                options, emptyList(), recipeList, dataTables, maintainers, contributors, examples, source);
+    }
+
     /**
      * @param env Provides a source of category descriptors to build category names from more
      *            than just the name segments.

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

@@ -0,0 +1,30 @@
+/*
+ * 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.config;
+
+import org.openrewrite.Recipe;
+
+import java.util.List;
+
+/**
+ * Indicates that a recipe exposes a list of recipes used as preconditions.
+ * This is purely informational and not taken into consideration by recipe execution.
+ * Imperative recipes interact with preconditions as implementation details of their visitor(s).
+ * There is no reason for an imperative recipe to implement this, it will not affect the behavior of the recipe in any way.
+ */
+public interface RecipePreconditions {
+    List<Recipe> getPreconditions();
+}

rewrite-core/src/main/java/org/openrewrite/marketplace/RecipeClassLoader.java

@@ -22,6 +22,7 @@
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.*;
 import java.util.stream.Stream;
@@ -215,14 +216,23 @@ protected List<String> getAdditionalParentDelegatedPackages() {
 
     /**
      * Convert paths to URL array for URLClassLoader.
+     * Directories must have URLs ending with '/' for URLClassLoader to recognize them.
      */
     public static URL[] getUrls(@Nullable Path recipeJar, List<Path> classpath) {
         return Stream.concat(classpath.stream(), Stream.of(recipeJar))
                 .filter(Objects::nonNull)
-                .map(Path::toUri)
-                .map(uri -> {
+                .map(path -> {
                     try {
-                        return uri.toURL();
+                        if (Files.isDirectory(path)) {
+                            // For directories, ensure URL ends with '/'
+                            String urlString = path.toUri().toURL().toString();
+                            if (!urlString.endsWith("/")) {
+                                urlString += "/";
+                            }
+                            return new URL(urlString);
+                        } else {
+                            return path.toUri().toURL();
+                        }
                     } catch (MalformedURLException e) {
                         throw new UncheckedIOException(e);
                     }