Allows to integrate Rewrite YAML snippets and recipes by name into SBM recipes

- Split generic RecipeLoader into SbmRecipeLoader and RewriteRecipeLoader

Author: fabapp2

applications/spring-shell/src/test/java/org/springframework/sbm/shell/RecipesAreFound.java

@@ -1,7 +1,10 @@
-## [0.11.2](https://github.com/spring-projects-experimental/spring-boot-migrator/releases/tag/0.11.2) - 2022-05-27
+## [0.12.0](https://github.com/spring-projects-experimental/spring-boot-migrator/releases/tag/0.12.0) - 
 
 ### Adds
-- 
+- Reworked OpenRewrite recipe integration. (#181)
+  - OpenRewriteDeclarativeRecipeAdapter allows to declare SBM action which applies a declarative OR recipe
+  - OpenRewriteNamedRecipeAdapter allows to declare SBM action which applies an OR recipe by name
+- Bumps OpenRewrite to version 7.22.0 (#174)
 
 ### Fixes
 - Fix Conditions for Spring Boot 2.4 to 2.5 Upgrade recipes (#133). Thanks @Turbots

changelog.md

@@ -58,7 +58,8 @@ private RecipeTestSupport() {
             ValidatorConfiguration.class,
             YamlObjectMapperConfiguration.class,
             ResourceHelperDummy.class,
-            RecipeLoader.class,
+            RewriteRecipeLoader.class,
+            SbmRecipeLoader.class,
             BasePackageCalculator.class,
             ActionDeserializerRegistry.class
     };

components/recipe-test-support/src/main/java/org/springframework/sbm/test/RecipeTestSupport.java

@@ -17,28 +17,29 @@
 package org.springframework.sbm.common.filter;
 
 import lombok.RequiredArgsConstructor;
+import org.openrewrite.SourceFile;
 import org.springframework.sbm.project.resource.ProjectResource;
 import org.springframework.sbm.project.resource.ProjectResourceSet;
+import org.springframework.sbm.project.resource.RewriteSourceFileHolder;
 import org.springframework.sbm.project.resource.filter.ProjectResourceFinder;
 
 import java.nio.file.Path;
 import java.util.Optional;
 
 @RequiredArgsConstructor
-public class AbsolutePathResourceFinder implements ProjectResourceFinder<Optional<ProjectResource>> {
+public class AbsolutePathResourceFinder implements ProjectResourceFinder<Optional<RewriteSourceFileHolder<? extends SourceFile>>> {
 
     private final Path absoluteResourcePath;
 
     @Override
-    public Optional<ProjectResource> apply(ProjectResourceSet projectResourceSet) {
+    public Optional<RewriteSourceFileHolder<? extends SourceFile>> apply(ProjectResourceSet projectResourceSet) {
         if (absoluteResourcePath == null || ! absoluteResourcePath.isAbsolute()) {
             throw new IllegalArgumentException("Given path '"+absoluteResourcePath+"' is not absolute");
         }
         Path searchForPath = absoluteResourcePath.normalize();
         return projectResourceSet
                 .stream()
                 .filter(r -> searchForPath.equals(r.getAbsolutePath()))
-                .map(ProjectResource.class::cast)
                 .findFirst();
 
     }

components/sbm-core/src/main/java/org/springframework/sbm/common/filter/AbsolutePathResourceFinder.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2021 - 2022 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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 org.springframework.sbm.common.filter;
+
+import org.openrewrite.SourceFile;
+import org.springframework.sbm.project.resource.ProjectResource;
+import org.springframework.sbm.project.resource.ProjectResourceSet;
+import org.springframework.sbm.project.resource.RewriteSourceFileHolder;
+import org.springframework.sbm.project.resource.filter.ProjectResourceFinder;
+
+import java.nio.file.Path;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class AbsolutePathResourcesFinder implements ProjectResourceFinder<List<RewriteSourceFileHolder<? extends SourceFile>>> {
+
+    private final Set<Path> absoluteResourcePaths;
+    public AbsolutePathResourcesFinder(List<Path> absoluteResourcePaths) {
+        this(new HashSet<>(absoluteResourcePaths));
+    }
+    public AbsolutePathResourcesFinder(Path... absoluteResourcePath) {
+        this(Arrays.asList(absoluteResourcePath));
+    }
+    public AbsolutePathResourcesFinder(Path absoluteResourcePath) {
+        this(Set.of(absoluteResourcePath));
+    }
+    public AbsolutePathResourcesFinder(Set<Path> absoluteResourcePaths) {
+        String invalidPaths = absoluteResourcePaths.stream()
+                .filter(absoluteResourcePath -> absoluteResourcePath == null || !absoluteResourcePath.isAbsolute())
+                .map(p -> {
+                    if(p == null) {
+                        return "null";
+                    } else  {
+                        return p.toString();
+                    }
+                })
+                .collect(Collectors.joining("', '"));
+
+        if(invalidPaths != null) {
+            throw new IllegalArgumentException("Given paths '"+ invalidPaths +"' were not absolute");
+        }
+
+        this.absoluteResourcePaths = absoluteResourcePaths.stream().map(Path::normalize).collect(Collectors.toSet());
+    }
+
+    @Override
+    public List<RewriteSourceFileHolder<? extends SourceFile>> apply(ProjectResourceSet projectResourceSet) {
+        return projectResourceSet
+                .stream()
+                .filter(r -> absoluteResourcePaths.contains(r.getAbsolutePath()))
+                .collect(Collectors.toList());
+    }
+}

components/sbm-core/src/main/java/org/springframework/sbm/common/filter/AbsolutePathResourcesFinder.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 - 2022 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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 org.springframework.sbm.engine.recipe;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.*;
+import org.openrewrite.Recipe;
+import org.openrewrite.Result;
+import org.openrewrite.SourceFile;
+import org.openrewrite.config.YamlResourceLoader;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.sbm.engine.context.ProjectContext;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.List;
+import java.util.Properties;
+
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class OpenRewriteDeclarativeRecipeAdapter extends AbstractAction {
+    @Setter
+    @Getter
+    private String openRewriteRecipe;
+
+    @JsonIgnore
+    @Autowired
+    private RewriteMigrationResultMerger resultMerger;
+
+    @Override
+    public boolean isApplicable(ProjectContext context) {
+        return super.isApplicable(context);
+    }
+
+    @Override
+    public void apply(ProjectContext context) {
+        ByteArrayInputStream yamlInput = new ByteArrayInputStream(openRewriteRecipe.getBytes(StandardCharsets.UTF_8));
+        URI source = URI.create("embedded-recipe");
+        YamlResourceLoader yamlResourceLoader = new YamlResourceLoader(yamlInput, source, new Properties());
+        Collection<Recipe> rewriteYamlRecipe = yamlResourceLoader.listRecipes();
+        if(rewriteYamlRecipe.size() != 1) {
+            throw new RuntimeException(String.format("Ambiguous number of recipes found. Expected exactly one, found %s", rewriteYamlRecipe.size()));
+        }
+        Recipe recipe = rewriteYamlRecipe.iterator().next();
+        List<? extends SourceFile> rewriteSourceFiles = context.search(new OpenRewriteSourceFilesFinder());
+        List<Result> results = recipe.run(rewriteSourceFiles);
+        resultMerger.mergeResults(context, results);
+    }
+
+}

components/sbm-core/src/main/java/org/springframework/sbm/engine/recipe/OpenRewriteDeclarativeRecipeAdapter.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2021 - 2022 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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 org.springframework.sbm.engine.recipe;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.openrewrite.Recipe;
+import org.openrewrite.Result;
+import org.openrewrite.SourceFile;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.sbm.engine.context.ProjectContext;
+
+import java.util.List;
+
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class OpenRewriteNamedRecipeAdapter extends AbstractAction {
+
+    @Setter
+    private String openRewriteRecipeName;
+
+    @Autowired
+    @JsonIgnore
+    private RewriteRecipeLoader rewriteRecipeLoader;
+
+    @JsonIgnore
+    @Autowired
+    private RewriteMigrationResultMerger resultMerger;
+
+    @Override
+    public void apply(ProjectContext context) {
+        Recipe recipe = rewriteRecipeLoader.loadRewriteRecipe(openRewriteRecipeName);
+        List<? extends SourceFile> rewriteSourceFiles = context.search(new OpenRewriteSourceFilesFinder());
+        List<Result> results = recipe.run(rewriteSourceFiles);
+        resultMerger.mergeResults(context, results);
+    }
+}

components/sbm-core/src/main/java/org/springframework/sbm/engine/recipe/OpenRewriteNamedRecipeAdapter.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2021 - 2022 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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 org.springframework.sbm.engine.recipe;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.extern.slf4j.Slf4j;
+import org.openrewrite.*;
+import org.openrewrite.Recipe;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.sbm.common.filter.AbsolutePathResourceFinder;
+import org.springframework.sbm.engine.context.ProjectContext;
+import org.springframework.sbm.project.RewriteSourceFileWrapper;
+import org.springframework.sbm.project.resource.RewriteSourceFileHolder;
+
+import java.nio.file.Path;
+import java.util.*;
+
+@Slf4j
+//@RequiredArgsConstructor
+public class OpenRewriteRecipeAdapterAction extends AbstractAction {
+
+    private final Recipe recipe;
+
+    @JsonIgnore
+    @Autowired
+    private RewriteMigrationResultMerger resultMerger;
+
+//    private final ModifiableProjectResourceFactory modifiableProjectResourceFactory = new ModifiableProjectResourceFactory();
+
+
+    @Override
+    public boolean isApplicable(ProjectContext context) {
+        return true;
+        // FIXME: use getApplicableTest and getSingleSourceApplicableTest to calculate
+        /*
+        Method getApplicableTest = ReflectionUtils.findMethod(Recipe.class, "getApplicableTest");
+        ReflectionUtils.makeAccessible(getApplicableTest);
+        try {
+            TreeVisitor<?, ExecutionContext> visitor = (TreeVisitor<?, ExecutionContext>) getApplicableTest.invoke(recipe);
+            if(visitor == null) {
+                return true;
+            } else {
+                List<SourceFile> search = context.search(new OpenRewriteSourceFileFinder());
+                return visitor.visit(search, new InMemoryExecutionContext());
+            }
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        } catch (InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+         */
+    }
+
+    public OpenRewriteRecipeAdapterAction(Recipe recipe) {
+        this.recipe = recipe;
+    }
+
+    @Override
+    public String getDescription() {
+        return recipe.getDescription().isEmpty() ? recipe.getDisplayName() : recipe.getDescription();
+    }
+    
+    @Override
+    public void apply(ProjectContext context) {
+        List<? extends SourceFile> rewriteSourceFiles = context.search(new OpenRewriteSourceFilesFinder());
+        List<Result> results = recipe.run(rewriteSourceFiles);
+        resultMerger.mergeResults(context, results);
+    }
+
+
+}