rewrite single-clause case statements to assignments

Author: novaugust

CHANGELOG.md

@@ -5,6 +5,24 @@ they can and will change without that change being reflected in Styler's semanti
 
 ## main
 
+### Improvements
+
+Rewrite single-clause case statements to be assignments (h/t 🤖)
+
+```elixir
+# before
+case foo |> Bar.baz() |> Bop.boop() do
+  {:ok, widget} ->
+    x = y
+    wodget(widget)
+end
+
+# after
+{:ok, widget} = foo |> Bar.baz() |> Bop.boop()
+x = y
+wodget(widget)
+```
+
 ## 1.7.0
 
 Surprising how fast numbers go up when you're following semver.

lib/style/blocks.ex

@@ -43,6 +43,34 @@ defmodule Styler.Style.Blocks do
     end
   end
 
+  # case statements with 1 clause: thanks 🤖!
+  #
+  # ideally rewrite to use `=`, but can't do that when there's a `when` clause
+  def run({{:case, _, [_, [{_, [{:->, _, [[{:when, _, _} | _] | _]}]}]]}, _} = zipper, ctx), do: {:cont, zipper, ctx}
+  #
+  def run({{:case, m, [head, [{_, [{:->, _, [[lhs], rhs]}]}]]}, _} = zipper, ctx) do
+    rhs =
+      case rhs do
+        {:__block__, _, children} -> children
+        node -> [node]
+      end
+
+    zipper =
+      case Zipper.up(zipper) do
+        {{:=, am, [parent_lhs, _single_clause_case]}, _} = zipper ->
+          # this was a `x = case head, do: (lhs -> rhs)`. make it `x = lhs = head; rhs`
+          meta = [line: am[:line]]
+          Zipper.replace(zipper, {:=, meta, [parent_lhs, {:=, meta, [lhs, head]}]})
+
+        _ ->
+          zipper
+          |> Style.find_nearest_block()
+          |> Zipper.replace({:=, [line: m[:line]], [lhs, head]})
+      end
+
+    {:cont, Zipper.insert_siblings(zipper, rhs), ctx}
+  end
+
   def run({{:cond, _, [[{do_, clauses}]]}, _} = zipper, ctx) do
     # ensure all final `atom -> final_clause` use `true` for consistency.
     # `:else` is cute but consistency is all.

test/style/blocks_test.exs

@@ -11,6 +11,110 @@
 defmodule Styler.Style.BlocksTest do
   use Styler.StyleCase, async: true
 
+  describe "case statements with a single clause" do
+    test "noop for when" do
+      assert_style """
+      case foo do
+        bar when is_binary(bar) -> baz(bar)
+      end
+      """
+    end
+
+    test "changes to assignment" do
+      assert_style(
+        """
+        case foo do
+          bar -> baz(bar)
+        end
+        """,
+        """
+        bar = foo
+        baz(bar)
+        """
+      )
+
+      assert_style(
+        """
+        case foo |> Bar.baz() |> Bop.boop() do
+          {:ok, widget} ->
+            x = y
+            wodget(widget)
+        end
+        """,
+        """
+        {:ok, widget} = foo |> Bar.baz() |> Bop.boop()
+        x = y
+        wodget(widget)
+        """
+      )
+    end
+
+    test "with comments" do
+      assert_style(
+        """
+        # bar
+        bar
+
+        # head
+        case foo |> Bar.baz() |> Bop.boop() do
+          # clause
+          {:ok, widget} ->
+            # body
+            x = y
+            wodget(widget)
+        end
+        """,
+        """
+        # bar
+        bar
+
+        # head
+        # clause
+        {:ok, widget} = foo |> Bar.baz() |> Bop.boop()
+        # body
+        x = y
+        wodget(widget)
+        """
+      )
+    end
+
+    test "singleton parent" do
+      assert_style """
+      if foo do
+        case complex |> head() |> stuff() do
+          {:ok, whatever} ->
+            some_body(whatever)
+        end
+      end
+      """,
+      """
+      if foo do
+        {:ok, whatever} = complex |> head() |> stuff()
+        some_body(whatever)
+      end
+      """
+    end
+
+    test "when already an assignment" do
+      assert_style(
+        """
+        m
+
+        x =
+          case a do
+            b -> c
+          end
+        """,
+        """
+        m
+
+        x = b = a
+        c
+        """
+      )
+    end
+  end
+
   describe "case to if" do
     test "rewrites case true false to if else" do
       assert_style(

test/style/pipes_test.exs

@@ -184,6 +184,7 @@ defmodule Styler.Style.PipesTest do
         x =
           case y do
             :ok -> :ok |> IO.puts()
+            :error -> :error
           end
           |> bar()
           |> baz()
@@ -192,6 +193,7 @@ defmodule Styler.Style.PipesTest do
         case_result =
           case y do
             :ok -> IO.puts(:ok)
+            :error -> :error
           end
 
         x =
@@ -286,11 +288,8 @@ defmodule Styler.Style.PipesTest do
         |> foo()
         """,
         """
-        case_result =
-          case x do
-            x -> x
-          end
-
+        case_result = x = x
+        x
         foo(case_result)
         """
       )
@@ -300,6 +299,7 @@ defmodule Styler.Style.PipesTest do
         def foo do
           case x do
             x -> x
+            y -> y
           end
           |> foo()
         end
@@ -309,6 +309,7 @@ defmodule Styler.Style.PipesTest do
           case_result =
             case x do
               x -> x
+              y -> y
             end
 
           foo(case_result)

test/style/single_node_test.exs

@@ -279,11 +279,13 @@ defmodule Styler.Style.SingleNodeTest do
         """
         case foo do
           bar = _ -> :ok
+          _ -> :error
         end
         """,
         """
         case foo do
           bar -> :ok
+          _ -> :error
         end
         """
       )
@@ -292,11 +294,13 @@ defmodule Styler.Style.SingleNodeTest do
         """
         case foo do
           _ = bar -> :ok
+          _ = second_clause_to_maintain_case -> :ok
         end
         """,
         """
         case foo do
           bar -> :ok
+          second_clause_to_maintain_case -> :ok
         end
         """
       )