Crud repository extension (#242)

closes #236 

Co-authored-by: sanagaraj-pivotal <[email protected]>

Author: ashakirin

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

@@ -1,6 +1,22 @@
+/*
+ * 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;
 
 import org.jetbrains.annotations.NotNull;
+import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.openrewrite.maven.MavenParser;
 import org.openrewrite.xml.tree.Xml;
@@ -17,6 +33,7 @@ protected String getTestSubDir() {
     }
 
     @Test
+    @Tag("integration")
     void migrateSimpleApplication() {
         intializeTestProject();
 
@@ -29,6 +46,22 @@ void migrateSimpleApplication() {
         verifyYamlConfigurationUpdate();
         verifyPropertyConfigurationUpdate();
         verifyConstructorBindingRemoval();
+        verifyCrudRepoAddition();
+    }
+
+    private void verifyCrudRepoAddition() {
+
+        String studentRepo = loadJavaFile("org.springboot.example.upgrade", "StudentRepo");
+
+        assertThat(studentRepo).isEqualTo("""
+                package org.springboot.example.upgrade;
+                                
+                import org.springframework.data.repository.CrudRepository;
+                import org.springframework.data.repository.PagingAndSortingRepository;
+                                
+                public interface StudentRepo extends PagingAndSortingRepository<Student<?>, Long>, CrudRepository<Student<?>, Long> {
+                }
+                """);
     }
 
     private void verifyConstructorBindingRemoval() {

applications/spring-shell/src/test/resources/testcode/boot-migration-27-30/pom.xml

@@ -25,6 +25,10 @@
             <groupId>io.micrometer</groupId>
             <artifactId>micrometer-registry-prometheus</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>

applications/spring-shell/src/test/resources/testcode/boot-migration-27-30/src/main/java/org/springboot/example/upgrade/Student.java

@@ -0,0 +1,5 @@
+package org.springboot.example.upgrade;
+
+public class Student<T> {
+    private T name;
+}

applications/spring-shell/src/test/resources/testcode/boot-migration-27-30/src/main/java/org/springboot/example/upgrade/StudentRepo.java

@@ -0,0 +1,6 @@
+package org.springboot.example.upgrade;
+
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+public interface StudentRepo extends PagingAndSortingRepository<Student<?>, Long> {
+}

components/sbm-openrewrite/src/test/java/org/openrewrite/maven/java/ChangeTypeTest.java renamed to components/sbm-openrewrite/src/test/java/org/openrewrite/java/ChangeTypeTest.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.openrewrite.maven.java;
+package org.openrewrite.java;
 
 import org.junit.jupiter.api.Test;
 import org.openrewrite.Result;

components/sbm-recipes-boot-upgrade/pom.xml

@@ -71,5 +71,11 @@
             <artifactId>aspectjweaver</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.openrewrite</groupId>
+            <artifactId>rewrite-test</artifactId>
+            <version>${openrewrite.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

components/sbm-recipes-boot-upgrade/src/main/java/org/springframework/sbm/boot/upgrade_27_30/CrudRepositoryExtension.java

@@ -0,0 +1,92 @@
+/*
+ * 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.boot.upgrade_27_30;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.openrewrite.*;
+import org.openrewrite.internal.lang.Nullable;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+import org.springframework.sbm.boot.upgrade_27_30.helperrecipe.ImplementTypedInterface;
+
+import java.util.List;
+import java.util.Optional;
+
+public class CrudRepositoryExtension extends Recipe {
+    public static final String PAGING_AND_SORTING_REPOSITORY = "org.springframework.data.repository.PagingAndSortingRepository";
+    public static final String CRUD_REPOSITORY = "org.springframework.data.repository.CrudRepository";
+
+    @Override
+    public String getDisplayName() {
+        return "Extends CrudRepository for Interfaces that extends PagingAndSortingRepository";
+    }
+
+    @Override
+    protected @Nullable TreeVisitor<?, ExecutionContext> getApplicableTest() {
+        return new JavaIsoVisitor<>() {
+            @Override
+            public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext executionContext) {
+                return doesItExtendPagingAndSorting(classDecl) ? applyThisRecipe(classDecl) : ceaseVisit(classDecl);
+            }
+
+            private boolean doesItExtendPagingAndSorting(J.ClassDeclaration classDecl) {
+                if (classDecl.getType() == null) {
+                    return false;
+                }
+                return classDecl.getType().getInterfaces().stream()
+                        .anyMatch(impl -> impl.getFullyQualifiedName().equals(PAGING_AND_SORTING_REPOSITORY));
+            }
+
+            private J.ClassDeclaration ceaseVisit(J.ClassDeclaration classDecl) {
+                return classDecl;
+            }
+
+            @NotNull
+            private J.ClassDeclaration applyThisRecipe(J.ClassDeclaration classDecl) {
+                return classDecl.withMarkers(classDecl.getMarkers().searchResult());
+            }
+        };
+    }
+
+    @Override
+    protected JavaIsoVisitor<ExecutionContext> getVisitor() {
+        return new JavaIsoVisitor<>() {
+            @Override
+            public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext executionContext) {
+
+                Optional<JavaType.FullyQualified> pagingInterface = getExtendPagingAndSorting(classDecl);
+                if (pagingInterface.isEmpty()) {
+                    return classDecl;
+                }
+                List<JavaType> typeParameters = pagingInterface.get().getTypeParameters();
+                doAfterVisit(new ImplementTypedInterface<>(classDecl, CRUD_REPOSITORY, typeParameters));
+                return classDecl;
+            }
+
+            private Optional<JavaType.FullyQualified> getExtendPagingAndSorting(J.ClassDeclaration classDecl) {
+                if (classDecl.getType() == null) {
+                    return Optional.empty();
+                }
+                return classDecl.getType().getInterfaces().stream()
+                        .filter(impl -> impl.getFullyQualifiedName().equals(PAGING_AND_SORTING_REPOSITORY))
+                        .findAny();
+            }
+        };
+
+    }
+}

components/sbm-recipes-boot-upgrade/src/main/java/org/springframework/sbm/boot/upgrade_27_30/helperrecipe/ImplementTypedInterface.java

@@ -0,0 +1,162 @@
+/*
+ * 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.boot.upgrade_27_30.helperrecipe;
+
+import org.openrewrite.Tree;
+import org.openrewrite.internal.ListUtils;
+import org.openrewrite.internal.lang.Nullable;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.tree.*;
+import org.openrewrite.marker.Markers;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class ImplementTypedInterface<P> extends JavaIsoVisitor<P> {
+    private final J.ClassDeclaration scope;
+    private final JavaType.FullyQualified interfaceType;
+    private final List<JavaType> typeParameters;
+
+    public ImplementTypedInterface(J.ClassDeclaration scope, JavaType.FullyQualified interfaceType, List<JavaType> typeParameters) {
+        this.scope = scope;
+        this.interfaceType = interfaceType;
+        this.typeParameters = typeParameters;
+    }
+
+    public ImplementTypedInterface(J.ClassDeclaration scope, String interfaze, List<JavaType> typeParameters) {
+        this(scope, (JavaType.FullyQualified) JavaType.ShallowClass.build(interfaze), typeParameters);
+    }
+
+    public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, P p) {
+        J.ClassDeclaration c = super.visitClassDeclaration(classDecl, p);
+        if (c.isScope(this.scope) && (c.getImplements() == null || c.getImplements().stream().noneMatch((f) -> {
+            return TypeUtils.isAssignableTo(f.getType(), this.interfaceType);
+        }))) {
+            if (!classDecl.getSimpleName().equals(this.interfaceType.getClassName())) {
+                this.maybeAddImport(this.interfaceType);
+            }
+
+            TypeTree type = (TypeTree) TypeTree.build(classDecl.getSimpleName().equals(this.interfaceType.getClassName()) ? this.interfaceType.getFullyQualifiedName() : this.interfaceType.getClassName()).withType(this.interfaceType).withPrefix(Space.format(" "));
+            if (typeParameters != null && !typeParameters.isEmpty() && typeParameters.stream().noneMatch(tp -> tp instanceof JavaType.GenericTypeVariable)) {
+                type = new J.ParameterizedType(UUID.randomUUID(), Space.EMPTY, Markers.EMPTY, type, buildTypeParameters(typeParameters));
+            }
+            c = c.withImplements(ListUtils.concat(c.getImplements(), type));
+            JContainer<TypeTree> anImplements = c.getPadding().getImplements();
+
+            assert anImplements != null;
+
+            if (anImplements.getBefore().getWhitespace().isEmpty()) {
+                c = c.getPadding().withImplements(anImplements.withBefore(Space.format(" ")));
+            }
+        }
+
+        return c;
+    }
+
+    @Nullable
+    private JContainer<Expression> buildTypeParameters(List<JavaType> typeParameters) {
+        List<JRightPadded<Expression>> typeExpressions = new ArrayList<>();
+
+        int index = 0;
+        for (JavaType type : typeParameters) {
+            Expression typeParameterExpression = (Expression) buildTypeTree(type, (index++ == 0) ? Space.EMPTY : Space.format(" "));
+            if (typeParameterExpression == null) {
+                return null;
+            }
+            typeExpressions.add(new JRightPadded<>(
+                    typeParameterExpression,
+                    Space.EMPTY,
+                    Markers.EMPTY
+            ));
+        }
+        return JContainer.build(Space.EMPTY, typeExpressions, Markers.EMPTY);
+    }
+
+    private TypeTree buildTypeTree(@Nullable JavaType type, Space space) {
+        if (type == null || type instanceof JavaType.Unknown) {
+            return null;
+        } else if (type instanceof JavaType.FullyQualified) {
+
+            JavaType.FullyQualified fq = (JavaType.FullyQualified) type;
+
+            J.Identifier identifier = new J.Identifier(Tree.randomId(),
+                    space,
+                    Markers.EMPTY,
+                    fq.getClassName(),
+                    type,
+                    null
+            );
+
+            if (!fq.getTypeParameters().isEmpty()) {
+                JContainer<Expression> typeParameters = buildTypeParameters(fq.getTypeParameters());
+                if (typeParameters == null) {
+                    //If there is a problem resolving one of the type parameters, then do not return a type
+                    //expression for the fully-qualified type.
+                    return null;
+                }
+                return new J.ParameterizedType(
+                        Tree.randomId(),
+                        space,
+                        Markers.EMPTY,
+                        identifier,
+                        typeParameters
+                );
+
+            } else {
+                maybeAddImport(fq);
+                return identifier;
+            }
+        } else if (type instanceof JavaType.GenericTypeVariable) {
+            JavaType.GenericTypeVariable genericType = (JavaType.GenericTypeVariable) type;
+
+            if (!genericType.getName().equals("?")) {
+                return new J.Identifier(Tree.randomId(),
+                        space,
+                        Markers.EMPTY,
+                        genericType.getName(),
+                        type,
+                        null
+                );
+            }
+            JLeftPadded<J.Wildcard.Bound> bound = null;
+            NameTree boundedType = null;
+            if (genericType.getVariance() == JavaType.GenericTypeVariable.Variance.COVARIANT) {
+                bound = new JLeftPadded<>(Space.format(" "), J.Wildcard.Bound.Extends, Markers.EMPTY);
+            } else if (genericType.getVariance() == JavaType.GenericTypeVariable.Variance.CONTRAVARIANT) {
+                bound = new JLeftPadded<>(Space.format(" "), J.Wildcard.Bound.Super, Markers.EMPTY);
+            }
+
+            if (!genericType.getBounds().isEmpty()) {
+                boundedType = buildTypeTree(genericType.getBounds().get(0), Space.format(" "));
+                if (boundedType == null) {
+                    return null;
+                }
+            }
+
+            return new J.Wildcard(
+                    Tree.randomId(),
+                    space,
+                    Markers.EMPTY,
+                    bound,
+                    boundedType
+            );
+        }
+        return null;
+
+    }
+}
+

components/sbm-recipes-boot-upgrade/src/main/resources/recipes/boot-2.7-3.0-dependency-version-update.yaml

@@ -95,6 +95,13 @@
       description: Replace javax with new jakarta packages
       openRewriteRecipeName: org.openrewrite.java.migrate.JavaxMigrationToJakarta
 
+    - type: org.springframework.sbm.engine.recipe.OpenRewriteNamedRecipeAdapter
+      condition:
+        type: org.springframework.sbm.boot.upgrade.common.conditions.HasSpringBootParentOfVersion
+        versionStartingWith: "3.0."
+      description: Add CrudRepository interface extension additionaly to PagingAndSortingRepository
+      openRewriteRecipeName: org.springframework.sbm.boot.upgrade_27_30.CrudRepositoryExtension
+
     - type: org.springframework.sbm.engine.recipe.OpenRewriteDeclarativeRecipeAdapter
       condition:
         type: org.springframework.sbm.boot.upgrade.common.conditions.HasSpringBootParentOfVersion