optimize Req pipes

Author: novaugust

CHANGELOG.md

@@ -5,6 +5,23 @@ they can and will change without that change being reflected in Styler's semanti
 
 ## main
 
+### Improvements
+
+#### Req pipe optimizations
+
+[Req](https://github.com/wojtekmach/req) is a popular HTTP Client. If you aren't using it, you can just ignore this whole section!
+
+Reqs 1-arity "execute the request" functions (`delete get head patch post put request run`) have a 2-arity version that takes a superset of the arguments `Req.new/1` does as its first argument, and the typical `options` keyword list as its second argument. And so, many places developers are calling a 1-arity function can be replaced with a 2-arity function.
+
+More succinctly, these two statements are equivalent:
+
+- `foo |> Req.new() |> Req.merge(bar) |> Req.post!()`
+- `Req.post!(foo, bar)`
+
+Styler now rewrites the former to the latter, since "less is more" or "code is a liability".
+
+It also rewrites `|> Keyword.merge(bar) |> Req.foo()` to `|> Req.foo(bar)`. **This changes the program's behaviour**, since `Keyword.merge` would overwrite existing values in all cases, whereas `Req` 2-arity functions intelligently deep-merge values for some keys, like `:headers`.
+
 ## 1.9.1
 
 ### Fix

docs/pipes.md

@@ -153,3 +153,23 @@ d(c(a |> b))
 # At which point Styler will pipe-ify the entire chain
 a |> b() |> c() |> d()
 ```
+
+## Req
+
+[Req](https://github.com/wojtekmach/req) is a popular HTTP Client. If you aren't using it, you can just ignore this whole section!
+
+Styler ensures a minimal number of functions are being called when using any Req 1-arity execution functions (`delete get head patch post put request run` and their bangified versions).
+
+```elixir
+# before
+keyword |> Req.new() |> Req.merge(opts) |> Req.post!()
+# Styled:
+Req.post!(keyword, opts)
+
+# before
+foo |> Keyword.merge(opts) |> Req.head()
+# Styled:
+Req.head(foo, opts)
+```
+
+**This changes the program's behaviour**, since `Keyword.merge` would overwrite existing values in all cases, whereas `Req` 2-arity functions intelligently deep-merge values for some keys, like `:headers`.

lib/style/pipes.ex

@@ -413,6 +413,30 @@ defmodule Styler.Style.Pipes do
     {:|>, pm, [lhs, {Style.set_line(new, em[:line]), em, [mapper]}]}
   end
 
+  @req2 for fun <- ~w(delete get head patch post put request run), bang <- ["", "!"], fun = :"#{fun}#{bang}", do: fun
+
+  # rewrite `Keyword.merge(opt) |> Req.fun1()` to `Req.fun2(opt)` for 2 arity functions that take `opts` as a second arg
+  defp fix_pipe(
+         pipe_chain(
+           pm,
+           lhs,
+           {{:., _, [{_, _, [req_or_kw]}, :merge]}, m, [kw]},
+           {{:., _, [{_, _, [:Req]}, fun]} = req, _, []}
+         )
+       )
+       when req_or_kw in [:Req, :Keyword] and fun in @req2 do
+    fix_pipe({:|>, pm, [lhs, {req, m, [kw]}]})
+  end
+
+  # Req.new |> Req.fun1,2 -> Req.fun1,2
+  # all `fun` options take the same args as `Req.new`, so it's redundant to call Req.new before them
+  defp fix_pipe(
+         pipe_chain(pm, lhs, {{:., _, [{_, _, [:Req]}, :new]}, m, []}, {{:., _, [{_, _, [:Req]}, fun]} = req, _, args})
+       )
+       when fun in @req2 do
+    {:|>, pm, [lhs, {req, m, args}]}
+  end
+
   defp fix_pipe(node), do: node
 
   defp valid_pipe_start?({op, _, _}) when op in @special_ops, do: true

test/style/pipes_test.exs

@@ -1004,4 +1004,31 @@ defmodule Styler.Style.PipesTest do
       )
     end
   end
+
+  describe "Req pipes" do
+    @req2 for fun <- ~w(delete get head patch post put request run), bang <- ["", "!"], fun = :"#{fun}#{bang}", do: fun
+
+    test "X.merge |> Req.foo/1 -> Req.foo/2" do
+      for fun <- @req2, merger <- ~w(Req Keyword) do
+        assert_style "foo |> #{merger}.merge(opts) |> Req.#{fun}()", "Req.#{fun}(foo, opts)"
+        assert_style "a |> b |> #{merger}.merge(opts) |> Req.#{fun}()", "a |> b() |> Req.#{fun}(opts)"
+      end
+    end
+
+    test "Req.new |> Req.foo/1 -> Req.foo/2" do
+      for fun <- @req2 do
+        assert_style "foo |> Req.new() |> Req.#{fun}()", "Req.#{fun}(foo)"
+        assert_style "a |> b |> Req.new() |> Req.#{fun}()", "a |> b() |> Req.#{fun}()"
+        assert_style "foo |> Req.new() |> Req.#{fun}(c)", "Req.#{fun}(foo, c)"
+        assert_style "a |> b |> Req.new() |> Req.#{fun}(c)", "a |> b() |> Req.#{fun}(c)"
+      end
+    end
+
+    test "new |> merge |> foo" do
+      for fun <- @req2 do
+        assert_style "foo |> Req.new() |> Req.merge(bar) |> Req.#{fun}()", "Req.#{fun}(foo, bar)"
+        assert_style "a |> b() |> Req.new() |> Req.merge(bar) |> Req.#{fun}()", "a |> b() |> Req.#{fun}(bar)"
+      end
+    end
+  end
 end