Ternary operator should not be nested

src/main/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNested.java

@@ -0,0 +1,92 @@
+package org.openrewrite.staticanalysis;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Set;
+
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Recipe;
+import org.openrewrite.Tree;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.internal.lang.Nullable;
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.JavaVisitor;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaSourceFile;
+import org.openrewrite.java.tree.Space;
+import org.openrewrite.java.tree.Statement;
+import org.openrewrite.marker.Markers;
+
+
+public class TernaryOperatorsShouldNotBeNested extends Recipe {
+    @Override
+    public String getDisplayName() {
+        return "Ternary operators should not be nested";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Just because you can do something, doesn’t mean you should, and that’s the case with nested ternary operations. " +
+                "Nesting ternary operators results in the kind of code that may seem clear as day when you write it, " +
+                "but six months later will leave maintainers (or worse - future you) scratching their heads and cursing.\n\n" +
+                "Instead, err on the side of clarity, and use another line to express the nested operation as a separate statement.";
+    }
+
+    @Override
+    public Duration getEstimatedEffortPerOccurrence() {
+        return Duration.ofMinutes(5);
+    }
+
+    @Override
+    public Set<String> getTags() {
+        return Collections.singleton("RSPEC-3358");
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return new TernaryOperatorsShouldNotBeNestedVisitor();
+    }
+
+    private static class TernaryOperatorsShouldNotBeNestedVisitor extends JavaVisitor<ExecutionContext> {
+
+        final JavaTemplate iffTemplate = JavaTemplate.builder(this::getCursor, "if(#{any(boolean)}) {}").build();
+
+        @Override
+        public @Nullable J visit(@Nullable final Tree tree, final ExecutionContext executionContext) {
+            J result = super.visit(tree, executionContext);
+            if (tree instanceof JavaSourceFile) {
+                result = (J) new RemoveUnneededBlock().getVisitor().visit(result, executionContext);
+            }
+            return result;
+        }
+
+        @Override
+        public J visitReturn(final J.Return retrn, final ExecutionContext executionContext) {
+            J possiblyTernary = retrn.getExpression();
+            if (possiblyTernary instanceof J.Ternary) {
+                J.Ternary ternary = (J.Ternary) possiblyTernary;
+                if (ternary.getFalsePart() instanceof J.Ternary || ternary.getTruePart() instanceof J.Ternary) {
+                    J.If iff = retrn.withTemplate(
+                            iffTemplate,
+                            retrn.getCoordinates().replace(),
+                            ternary.getCondition()
+                    );
+                    iff = iff.withThenPart(blockOf(returnOf(ternary.getTruePart())));
+                    J result = blockOf(iff, returnOf(ternary.getFalsePart()));
+                    return autoFormat(result, executionContext);
+                }
+            }
+            return super.visitReturn(retrn, executionContext);
+        }
+    }
+
+    private static J.Return returnOf(Expression expression) {
+        return new J.Return(Tree.randomId(), Space.EMPTY, Markers.EMPTY, expression);
+    }
+
+    private static J.Block blockOf(Statement... statements) {
+        return J.Block.createEmptyBlock().withStatements(Arrays.asList(statements));
+    }
+}

src/test/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNestedTest.java

@@ -0,0 +1,158 @@
+package org.openrewrite.staticanalysis;
+
+import static org.openrewrite.java.Assertions.java;
+
+import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.ExpectedToFail;
+import org.openrewrite.Issue;
+import org.openrewrite.test.RecipeSpec;
+import org.openrewrite.test.RewriteTest;
+
+class TernaryOperatorsShouldNotBeNestedTest implements RewriteTest {
+
+    @Override
+    public void defaults(RecipeSpec spec) {
+        spec.recipe(new TernaryOperatorsShouldNotBeNested());
+    }
+
+    @Test
+    void doReplaceNestedOrTernaryWithIfFollowedByTernary() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class Test {
+                public String determineSomething(String a, String b) {
+                  return "a".equals(a) ? "a" : "b".equals(b) ? "b" : "nope";
+                }
+              }
+              """,
+            """
+              class Test {
+                public String determineSomething(String a, String b) {
+                    if ("a".equals(a)) {
+                        return "a";
+                    }
+                    return "b".equals(b) ? "b" : "nope";
+                }
+              }
+              """
+          )
+        );
+    }
+
+    @Test
+    void doReplaceNestedOrTernaryRecursive() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class Test {
+                public String determineSomething(String a, String b, String c) {
+                  return "a".equals(a) ? "a" : "b".equals(b) ? "b" : "c".equals(b) ? "c" :"nope";
+                }
+              }
+              """,
+            """
+              class Test {
+                public String determineSomething(String a, String b, String c) {
+                    if ("a".equals(a)) {
+                        return "a";
+                    }
+                    if ("b".equals(b)) {
+                        return "b";
+                    }
+                    return "c".equals(b) ? "c" : "nope";
+                }
+              }
+              """
+          )
+        );
+    }
+
+    @Test
+    void doReplaceNestedAndTernaryWithIfThenTernary() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class Test {
+                public String determineSomething(String a, String b) {
+                  return "a".equals(a) ? "b".equals(b) ? "b" : "a" : "nope";
+                }
+              }
+              """,
+            """
+              class Test {
+                public String determineSomething(String a, String b) {
+                    if ("a".equals(a)) {
+                        return "b".equals(b) ? "b" : "a";
+                    }
+                    return "nope";
+                }
+              }
+              """
+          )
+        );
+    }
+
+    @Test
+    void doReplaceNestedAndOrTernaryWithIfThenTernaryElseTernary() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class Test {
+                public String determineSomething(String a, String b, String c) {
+                  return "a".equals(a) ? "b".equals(b) ? "b" : "a" : "c".equals(c) ? "c" : "nope";
+                }
+              }
+              """,
+            """
+              class Test {
+                public String determineSomething(String a, String b, String c) {
+                    if ("a".equals(a)) {
+                        return "b".equals(b) ? "b" : "a";
+                    }
+                    return "c".equals(c) ? "c" : "nope";
+                }
+              }
+              """
+          )
+        );
+    }
+
+    @Issue("todo")
+    @ExpectedToFail("only directly returned ternaries are taken into account")
+    @Test
+    void doReplaceNestedOrAssignmentTernaryWithIfElse() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class Test {
+                public void doThing(String a, String b) {
+                  String result = "a".equals(a) ? "a" : "b".equals(b) ? "b" : "nope";
+                  System.out.println(result);
+                }
+              }
+              """,
+            """
+              class Test {
+                public void doThing(String a, String b) {
+                    String result;
+                    if ("a".equals(a)) {
+                      result = "a";
+                    }
+                    else {
+                      result = "b".equals(b) ? "b" : "nope";
+                    }
+                    System.out.println(result);
+                }
+              }
+              """
+          )
+        );
+    }
+
+}