dont rewrite then(&f(&1, ... &1 ...))

Author: novaugust

lib/style/pipes.ex

@@ -145,8 +145,13 @@ defmodule Styler.Style.Pipes do
   # a |> then(&fun/1) |> c => a |> fun() |> c()
   defp fix_pipe({:|>, m, [lhs, {:then, _, [{:&, _, [{:/, _, [{fun, m2, _}, _]}]}]}]}), do: {:|>, m, [lhs, {fun, m2, []}]}
   # a |> then(&fun(&1, d)) |> c => a |> fun(d) |> c()
-  defp fix_pipe({:|>, m, [lhs, {:then, _, [{:&, _, [{fun, m2, [{:&, _, _} | args]}]}]}]}),
-    do: {:|>, m, [lhs, {fun, m2, args}]}
+  defp fix_pipe({:|>, m, [lhs, {:then, _, [{:&, _, [{fun, m2, [{:&, _, _} | args]}]}]}]} = pipe) do
+    rewrite = {fun, m2, args}
+    # if `&1` is referenced more than once, we have to continue using `then`
+    if rewrite |> Zipper.zip() |> Zipper.any?(&match?({:&, _, _}, &1)),
+      do: pipe,
+      else: {:|>, m, [lhs, rewrite]}
+  end
 
   # Credo.Check.Readability.PipeIntoAnonymousFunctions
   # rewrite anonymous function invocation to use `then/2`

lib/zipper.ex

@@ -381,12 +381,23 @@ defmodule Styler.Zipper do
   """
   @spec find(zipper, direction :: :prev | :next, predicate :: (tree -> any)) :: zipper | nil
   def find({tree, _} = zipper, direction \\ :next, predicate)
-      when direction in [:next, :prev] and is_function(predicate) do
+      when direction in [:next, :prev] and is_function(predicate, 1) do
     if predicate.(tree) do
       zipper
     else
       zipper = if direction == :next, do: next(zipper), else: prev(zipper)
       zipper && find(zipper, direction, predicate)
     end
   end
+
+  @doc "Traverses `zipper`, returning true when `fun.(Zipper.node(zipper))` is truthy, or false otherwise"
+  @spec any?(zipper, (tree -> term)) :: boolean()
+  def any?({_, _} = zipper, fun) when is_function(fun, 1) do
+    zipper
+    |> traverse_while(false, fn {tree, _} = zipper, _ ->
+      # {nil, nil} optimizes to not go back to the top of the zipper on a hit
+      if fun.(tree), do: {:halt, {nil, nil}, true}, else: {:cont, zipper, false}
+    end)
+    |> elem(1)
+  end
 end