pipes_test.exs

# Copyright 2024 Adobe. All rights reserved.
# This file is licensed to you 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 http://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 REPRESENTATIONS
# OF ANY KIND, either express or implied. See the License for the specific language
# governing permissions and limitations under the License.

defmodule Styler.Style.PipesTest do
  use Styler.StyleCase, async: true

  describe "big picture / readability" do
    test "unnests multiple steps" do
      assert_style("f(g(h(x))) |> j()", "x |> h() |> g() |> f() |> j()")
    end

    test "doesn't modify valid pipe" do
      assert_style("""
      a()
      |> b()
      |> c()

      a |> b() |> c()
      """)
    end

    test "extracts >0 arity functions" do
      assert_style(
        """
        M.f(a, b)
        |> g()
        |> h()
        """,
        """
        a
        |> M.f(b)
        |> g()
        |> h()
        """
      )
    end

    test "fixes nested pipes" do
      assert_style(
        """
        a
        |> e(fn x ->
          with({:ok, value} <- efoo(x), do: value)
          |> ebar()
          |> ebaz()
        end)
        |> b(fn x ->
          with({:ok, value} <- foo(x), do: value)
          |> bar()
          |> baz()
        end)
        |> c
        """,
        """
        a
        |> e(fn x ->
          with_result = with({:ok, value} <- efoo(x), do: value)

          with_result
          |> ebar()
          |> ebaz()
        end)
        |> b(fn x ->
          with_result = with({:ok, value} <- foo(x), do: value)

          with_result
          |> bar()
          |> baz()
        end)
        |> c()
        """
      )
    end

    test "rewrites anonymous function invocations to use then" do
      assert_style("a |> (& &1).()", "then(a, & &1)")
      assert_style("a |> (& {&1, &2}).(b)", "(&{&1, &2}).(a, b)")
      assert_style("a |> (& &1).() |> c", "a |> then(& &1) |> c()")

      assert_style("a |> (fn x, y -> {x, y} end).() |> c", "a |> then(fn x, y -> {x, y} end) |> c()")
      assert_style("a |> (fn x -> x end).()", "then(a, fn x -> x end)")
      assert_style("a |> (fn x -> x end).() |> c", "a |> then(fn x -> x end) |> c()")
    end
  end

  describe "block pipe starts" do
    test "parent is a function invocation" do
      assert_style(
        "a(if x do y end |> foo(), b)",
        """
        if_result =
          if x do
            y
          end

        if_result |> foo() |> a(b)
        """
      )
    end

    test "handles arbitrary do-block macros" do
      assert_style("""
      IO.puts(
        foo meow do
          :foo
        end
      )
      """)

      assert_style(
        """
        foo do
          "foo"
        end
        |> IO.puts()
        """,
        """
        foo_result =
          foo do
            "foo"
          end

        IO.puts(foo_result)
        """
      )

      assert_style(
        """
        foo meow? do
          :meow
        else
          :bark
        end
        |> IO.puts()
        """,
        """
        foo_result =
          foo meow? do
            :meow
          else
            :bark
          end

        IO.puts(foo_result)
        """
      )
    end

    test "block extraction: names aliased modules" do
      assert_style(
        """
        Foo.bar do
          :ok
        end
        |> case do
          :ok -> :ok
          _ -> :error
        end
        """,
        """
        bar_result =
          Foo.bar do
            :ok
          end

        case bar_result do
          :ok -> :ok
          _ -> :error
        end
        """
      )
    end

    test "macro with arg and do block" do
      assert_style("""
      "baz"
      |> foo do
        "foo"
      end
      |> IO.puts()
      """)
    end

    test "variable assignment of a block" do
      assert_style(
        """
        x =
          case y do
            :ok -> :ok |> IO.puts()
            :error -> :error
          end
          |> bar()
          |> baz()
        """,
        """
        case_result =
          case y do
            :ok -> IO.puts(:ok)
            :error -> :error
          end

        x =
          case_result
          |> bar()
          |> baz()
        """
      )
    end

    test "rewrites fors" do
      assert_style(
        """
        for(a <- as, do: a)
        |> bar()
        |> baz()
        """,
        """
        for_result = for(a <- as, do: a)

        for_result
        |> bar()
        |> baz()
        """
      )
    end

    test "rewrites unless" do
      assert_style(
        """
        unless foo do
          bar
        end
        |> wee()
        """,
        """
        if_result =
          if !foo do
            bar
          end

        wee(if_result)
        """
      )
    end

    test "rewrites with" do
      assert_style(
        """
        with({:ok, value} <- foo(), do: value)
        |> bar()
        |> baz()
        """,
        """
        with_result = with({:ok, value} <- foo(), do: value)

        with_result
        |> bar()
        |> baz()
        """
      )
    end

    test "rewrites conds" do
      assert_style(
        """
        cond do
          x -> :ok
        end
        |> bar()
        |> baz()
        """,
        """
        cond_result =
          cond do
            x -> :ok
          end

        cond_result
        |> bar()
        |> baz()
        """
      )
    end

    test "rewrites case" do
      assert_style(
        """
        case x do
          y -> z
        end
        |> foo()
        """,
        """
        y = x
        case_result = z
        foo(case_result)
        """
      )

      assert_style(
        """
        def foo do
          case x do
            x -> x
            y -> y
          end
          |> foo()
        end
        """,
        """
        def foo do
          case_result =
            case x do
              x -> x
              y -> y
            end

          foo(case_result)
        end
        """
      )
    end

    test "rewrites if" do
      assert_style(
        """
        def foo do
          if true do
            nil
          end
          |> a()
          |> b()
        end
        """,
        """
        def foo do
          if_result =
            if true do
              nil
            end

          if_result
          |> a()
          |> b()
        end
        """
      )
    end

    test "rewrites quote" do
      assert_style(
        """
        quote do
          foo
        end
        |> bar()
        |> baz()
        """,
        """
        quote_result =
          quote do
            foo
          end

        quote_result
        |> bar()
        |> baz()
        """
      )
    end
  end

  describe "single pipe issues" do
    test "allows unquote single pipes" do
      assert_style("foo |> unquote(bar)")
    end

    test "fixes simple single pipes" do
      assert_style("b(a) |> c()", "a |> b() |> c()")
      assert_style("a |> f()", "f(a)")
      assert_style("x |> bar", "bar(x)")
      assert_style("def a, do: b |> c()", "def a, do: c(b)")
    end

    test "keeps invocation on a single line" do
      assert_style(
        """
        foo
        |> bar(baz, bop, boom)
        """,
        """
        bar(foo, baz, bop, boom)
        """
      )

      assert_style(
        """
        foo
        |> bar(baz)
        """,
        """
        bar(foo, baz)
        """
      )

      assert_style(
        """
        def halt(exec, halt_message) do
          %{exec | halted: true}
          |> put_halt_message(halt_message)
        end
        """,
        """
        def halt(exec, halt_message) do
          put_halt_message(%{exec | halted: true}, halt_message)
        end
        """
      )

      assert_style(
        """
        if true do
          false
        end
        |> foo(
          bar
        )
        """,
        """
        if_result =
          if true do
            false
          end

        foo(if_result, bar)
        """
      )
    end

    test "onelines assignments" do
      assert_style(
        """
        x =
          y
          |> Enum.map(&f/1)
          |> Enum.join()
        """,
        "x = Enum.map_join(y, &f/1)"
      )
    end
  end

  describe "valid pipe starts & unpiping" do
    test "kernel unary starts" do
      assert_style("!b |> c() |> d()", "!b |> c() |> d()")
      assert_style("!x(b) |> c() |> d()")
      assert_style("not(b) |> c() |> d()", "not b |> c() |> d()")
      assert_style("not x(b) |> c() |> d()")
    end

    test "writes brackets for unpiped kwl" do
      assert_style("foo(kwl: arg) |> bar()", "[kwl: arg] |> foo() |> bar()")
      assert_style("%{a: foo(a: b, c: :d) |> bar()}", "%{a: [a: b, c: :d] |> foo() |> bar()}")
      assert_style("%{a: foo([a: :b, c: :d]) |> bar()}", "%{a: [a: :b, c: :d] |> foo() |> bar()}")
    end

    test "allows fn" do
      assert_style("""
      fn
        :ok -> :ok
        :error -> :error
      end
      |> b()
      |> c()
      """)
    end

    test "recognizes infix ops as valid pipe starts" do
      assert_style("(bar() == 1) |> foo()", "foo(bar() == 1)")
      assert_style("(x in 1..100) |> foo()", "foo(x in 1..100)")
    end

    test "0 arity is just fine!" do
      assert_style("foo() |> bar() |> baz()")
      assert_style("Module.foo() |> bar() |> baz()")
    end

    test "ecto funtimes" do
      for from <- ~w(from Query.from Ecto.Query.from) do
        assert_style("""
        #{from}(foo in Bar, where: foo.bool)
        |> some_query_helper()
        |> Repo.all()
        """)
      end

      assert_style("^foo |> Ecto.Query.bar() |> Ecto.Query.baz()")
    end

    test "ranges" do
      assert_style("start..stop//step |> foo()", "foo(start..stop//step)")
      assert_style("start..stop//step |> foo() |> bar()")
      assert_style("foo(start..stop//step) |> bar()", "start..stop//step |> foo() |> bar()")
    end
  end

  describe "readability" do
    test "rewrites then/2 when the passed function is a named function reference" do
      assert_style "a |> then(&fun/1) |> c", "a |> fun() |> c()"
      assert_style "a |> then(&(&1 / 1)) |> c", "a |> Kernel./(1) |> c()"
      assert_style "a |> then(&(&1 * 2 / 1)) |> c()"
      assert_style "a |> then(&fun/1)", "fun(a)"
      assert_style "a |> then(&fun(&1)) |> c", "a |> fun() |> c()"
      assert_style "a |> then(&fun(&1, d)) |> c", "a |> fun(d) |> c()"
      assert_style "a |> then(&M.f(&1)) |> c", "a |> M.f() |> c()"

      # Doesn't rewrite multiple refs / non-starting argument
      assert_style "a |> then(&fun(d, &1)) |> c()"
      assert_style "a |> then(&fun(&1, d, %{foo: &1})) |> c()"

      # then + kernel ops
      assert_style "a |> then(&(-&1)) |> c", "a |> Kernel.-() |> c()"
      assert_style "a |> then(&(+&1)) |> c", "a |> Kernel.+() |> c()"

      for op <- ~w(++ -- && || in - * + / > < <= >= == and or != !== === <>) do
        assert_style "a |> then(&(&1 #{op} x)) |> c", "a |> Kernel.#{op}(x) |> c()"
      end

      # Doesn't rewrite non-kernel operators
      for op <- ~w(||| &&& <<< >>> <<~ ~>> <~ ~> <~>) do
        assert_style "a |> then(&(&1 #{op} x)) |> c()"
      end
    end

    test "adds parens to 1-arity pipes" do
      assert_style("a |> b |> c", "a |> b() |> c()")
    end
  end

  describe "optimizations for stdlib functions" do
    test "map/intersperse => map_intersperse" do
      assert_style "a |> Enum.map(fun) |> Enum.intersperse(sep)", "Enum.map_intersperse(a, sep, fun)"

      assert_style(
        """
        a
        |> Enum.map(fun)
        |> Enum.intersperse(sep)
        |> foo()
        """,
        """
        a
        |> Enum.map_intersperse(sep, fun)
        |> foo()
        """
      )
    end

    test "filter/first => find" do
      assert_style "a |> Enum.filter(fun) |> List.first()", "Enum.find(a, fun)"
      assert_style "a |> Enum.filter(fun) |> List.first(default)", "Enum.find(a, default, fun)"

      assert_style(
        """
        a
        |> Enum.filter(fun)
        |> List.first()
        |> foo()
        """,
        """
        a
        |> Enum.find(fun)
        |> foo()
        """
      )

      assert_style(
        """
        a
        |> Enum.filter(fun)
        |> List.first(default)
        |> foo()
        """,
        """
        a
        |> Enum.find(default, fun)
        |> foo()
        """
      )
    end

    test "Enum.sort/Enum.reverse" do
      assert_style("a |> Enum.sort(direction) |> Enum.reverse()")
      assert_style("a |> Enum.sort(:asc) |> Enum.reverse()", "Enum.sort(a, :desc)")
      assert_style("a |> Enum.sort(:desc) |> Enum.reverse()", "Enum.sort(a, :asc)")
      assert_style("a |> Enum.sort() |> Enum.reverse()", "Enum.sort(a, :desc)")
    end

    test "reverse/concat" do
      assert_style("a |> Enum.reverse() |> Enum.concat()")
      assert_style("a |> Enum.reverse(bar) |> Enum.concat()")
      assert_style("a |> Enum.reverse(bar) |> Enum.concat(foo)")
      assert_style("a |> Enum.reverse() |> Enum.concat(foo)", "Enum.reverse(a, foo)")

      assert_style(
        """
        a
        |> Enum.reverse()
        |> Enum.concat([bar, baz])
        |> Enum.sum()
        """,
        """
        a
        |> Enum.reverse([bar, baz])
        |> Enum.sum()
        """
      )
    end

    test "reverse/Kernel.++" do
      assert_style("a |> Enum.reverse(bar) |> Kernel.++(foo)")
      assert_style("a |> Enum.reverse() |> Kernel.++(foo)", "Enum.reverse(a, foo)")

      assert_style(
        """
        a
        |> Enum.reverse()
        |> Kernel.++([bar, baz])
        |> Enum.sum()
        """,
        """
        a
        |> Enum.reverse([bar, baz])
        |> Enum.sum()
        """
      )
    end

    test "FilterFilter: combines two Enum.filter calls with &&" do
      assert_style(
        """
        list
        |> Enum.filter(f1)
        |> Enum.filter(f2)
        """,
        """
        Enum.filter(list, fn item -> f1.(item) && f2.(item) end)
        """
      )
    end

    test "FilterFilter: inlines captures and inline-fn predicates" do
      assert_style(
        """
        list
        |> Enum.filter(&String.contains?(&1, "x"))
        |> Enum.filter(fn s -> String.contains?(s, "a") end)
        """,
        """
        Enum.filter(list, fn s -> String.contains?(s, "x") && String.contains?(s, "a") end)
        """
      )
    end

    test "RejectFilter: inlines `&fun/1` style captures" do
      assert_style(
        """
        list
        |> Enum.reject(&is_nil/1)
        |> Enum.filter(&is_map/1)
        """,
        """
        Enum.filter(list, fn item -> not is_nil(item) && is_map(item) end)
        """
      )
    end

    test "FilterFilter: skips rewrite when chosen var name would shadow a closure" do
      # `item` is closed over by f1; merging with hardcoded `:item` would silently shadow it.
      assert_style("""
      list
      |> Enum.filter(&(&1.thing == item))
      |> Enum.filter(f2)
      """)

      # Bare-reference predicate named `:item` — same trap.
      assert_style("""
      list
      |> Enum.filter(item)
      |> Enum.filter(f2)
      """)
    end

    test "FilterFilter / RejectFilter: skips rewrite when a predicate has a multi-statement fn body" do
      # The collapsed lambda would be uglier than the original chain — leave it alone.
      assert_style("""
      schema_modules
      |> Enum.reject(&(&1 in context.ignore_list))
      |> Enum.filter(fn schema_module ->
        schema = schema_module.schema()
        schema_title = schema.title
        not is_nil(schema.example) and not MapSet.member?(set, schema_title)
      end)
      """)

      assert_style("""
      list
      |> Enum.filter(fn x ->
        y = x.a
        y > 0
      end)
      |> Enum.filter(f2)
      """)
    end

    test "FilterFilter: leaves non-Enum.filter chains alone" do
      assert_style("""
      list
      |> Stream.filter(f1)
      |> Stream.filter(f2)
      """)

      assert_style("""
      list
      |> Enum.map(f1)
      |> Enum.filter(f2)
      """)
    end

    test "RejectReject: combines two Enum.reject calls with ||" do
      assert_style(
        """
        list
        |> Enum.reject(f1)
        |> Enum.reject(f2)
        """,
        """
        Enum.reject(list, fn item -> f1.(item) || f2.(item) end)
        """
      )
    end

    test "FilterReject: collapses Enum.filter |> Enum.reject into one filter with the second negated" do
      assert_style(
        """
        list
        |> Enum.filter(f1)
        |> Enum.reject(f2)
        """,
        """
        Enum.filter(list, fn item -> f1.(item) && !f2.(item) end)
        """
      )
    end

    test "FilterReject: leaves chains alone when the modules don't both match Enum" do
      assert_style("""
      list
      |> Stream.filter(f1)
      |> Enum.reject(f2)
      """)

      assert_style("""
      list
      |> Enum.filter(f1)
      |> Stream.reject(f2)
      """)
    end

    test "RejectFilter: collapses Enum.reject |> Enum.filter into one filter with the first negated" do
      assert_style(
        """
        list
        |> Enum.reject(f1)
        |> Enum.filter(f2)
        """,
        """
        Enum.filter(list, fn item -> !f1.(item) && f2.(item) end)
        """
      )
    end

    test "RejectFilter: leaves chains alone when the modules don't both match Enum" do
      assert_style("""
      list
      |> Stream.reject(f1)
      |> Enum.filter(f2)
      """)

      assert_style("""
      list
      |> Enum.reject(f1)
      |> Stream.filter(f2)
      """)
    end

    test "MapMap: collapses two named-capture maps into a pipe" do
      assert_style(
        """
        list
        |> Enum.map(&Mod.foo/1)
        |> Enum.map(&Mod.bar/1)
        """,
        """
        Enum.map(list, fn arg1 -> arg1 |> Mod.foo() |> Mod.bar() end)
        """
      )

      assert_style(
        """
        list
        |> Enum.map(&foo/1)
        |> Enum.map(&bar/1)
        """,
        """
        Enum.map(list, fn arg1 -> arg1 |> foo() |> bar() end)
        """
      )
    end

    test "MapMap: collapses &fun(&1) shorthand into a pipe" do
      assert_style(
        """
        list
        |> Enum.map(&foo(&1))
        |> Enum.map(&Mod.bar(&1))
        """,
        """
        Enum.map(list, fn arg1 -> arg1 |> foo() |> Mod.bar() end)
        """
      )
    end

    test "MapMap: pivots on the first arg of f1 when its placeholder isn't there" do
      # User case from billing_core/.../process_bloomberg_import.ex. Both sides are inlineable;
      # f1 puts the placeholder in position 2, so the merge pivots on `import_record` (f1's first
      # arg). f1 is a capture so contributes no name; the merged lambda picks up `changeset` from
      # f2's `fn changeset -> ...`.
      assert_style(
        """
        list
        |> Enum.map(&build_changeset(import_record, &1))
        |> Enum.map(fn changeset -> Repo.insert(changeset, on_conflict: :nothing) end)
        """,
        """
        Enum.map(list, fn changeset -> import_record |> build_changeset(changeset) |> Repo.insert(on_conflict: :nothing) end)
        """
      )
    end

    test "MapMap: skips when either side can't be cleanly inlined" do
      # Variables (could be any function), multi-`&1` captures (would call f1 twice), and inline
      # fns whose body uses the var more than once or zero times — leave those alone.
      assert_style("""
      list
      |> Enum.map(f1)
      |> Enum.map(f2)
      """)

      assert_style("""
      list
      |> Enum.map(&foo/1)
      |> Enum.map(&(&1 + &1))
      """)

      assert_style("""
      list
      |> Enum.map(fn x -> x + x end)
      |> Enum.map(&Mod.fun/1)
      """)
    end

    test "MapMap: regression — extends an already-piped fn body without producing a malformed single-arg pipe" do
      # Repro from a real codebase: f1's body is itself a pipe (`element |> String.replace(...) |>
      # ...`). The merge needs to leave that pipe alone and just extend it with f2's call. Earlier,
      # `pipify` mis-treated the inner `:|>` as a regular call and produced `{:|>, _, [single_arg]}`,
      # which crashed `fix_pipe_start`.
      assert_style(
        """
        status
        |> Enum.map(fn element ->
          element |> String.replace(~r/([A-Z])/, "_\\\\1") |> String.downcase()
        end)
        |> Enum.map(fn element -> String.to_atom(element) end)
        """,
        """
        Enum.map(status, fn element -> element |> String.replace(~r/([A-Z])/, "_\\\\1") |> String.downcase() |> String.to_atom() end)
        """
      )
    end

    test "MapMap: skips when the merged body wouldn't make a 2+ stage pipe" do
      # `&(&1 + 1)` inlines to `arg + 1` which isn't a pipify-able call, so the merge would only
      # produce a single pipe (which Styler immediately undoes). Don't bother starting.
      assert_style("""
      list
      |> Enum.map(&(&1 + 1))
      |> Enum.map(&foo/1)
      """)
    end

    test "MapMap: skips when the iteration var name collides with a closure var in f2" do
      # Reported by Cursor Bugbot: picking f1's param name as the merged lambda's parameter would
      # shadow a same-named closure variable referenced in f2's body, silently changing semantics.
      assert_style("""
      list
      |> Enum.map(fn config -> transform(config) end)
      |> Enum.map(fn x -> apply_with(x, config) end)
      """)

      assert_style("""
      list
      |> Enum.map(fn config -> transform(config) end)
      |> Enum.map(&apply_with(&1, config))
      """)

      # Default `:arg1` iter-var case (neither side names its iter-var): a closure named `arg1` in
      # f1 must also block the merge.
      assert_style("""
      list
      |> Enum.map(&build_changeset(arg1, &1))
      |> Enum.map(&Repo.insert/1)
      """)
    end

    test "MapMap: leaves non-Enum.map chains alone" do
      assert_style("""
      list
      |> Stream.map(f1)
      |> Stream.map(f2)
      """)

      assert_style("""
      list
      |> Enum.map(f1)
      |> Enum.filter(f2)
      """)
    end

    test "filter/count" do
      for enum <- ~w(Enum Stream) do
        assert_style(
          """
          a
          |> #{enum}.filter(fun)
          |> Enum.count()
          |> IO.puts()
          """,
          """
          a
          |> Enum.count(fun)
          |> IO.puts()
          """
        )

        assert_style(
          """
          a
          |> b()
          |> #{enum}.filter(fun)
          |> Enum.count()
          """,
          """
          a
          |> b()
          |> Enum.count(fun)
          """
        )

        assert_style(
          """
          if true do
            []
          else
            [a, b, c]
          end
          |> #{enum}.filter(fun)
          |> Enum.count()
          """,
          """
          if_result =
            if true do
              []
            else
              [a, b, c]
            end

          Enum.count(if_result, fun)
          """
        )
      end
    end

    test "Stream.{each/map}/Stream.run" do
      assert_style("a |> Stream.each(fun) |> Stream.run()", "Enum.each(a, fun)")
      assert_style("a |> Stream.map(fun) |> Stream.run()", "Enum.each(a, fun)")

      assert_style(
        """
        a
        |> foo
        |> Stream.map(fun)
        |> Stream.run()
        """,
        """
        a
        |> foo()
        |> Enum.each(fun)
        """
      )
    end

    test "map/join" do
      for enum <- ~w(Enum Stream) do
        assert_style("a |> #{enum}.map(mapper) |> Enum.join()", "Enum.map_join(a, mapper)")

        assert_style(
          """
          a
          |> b()
          |> #{enum}.map(mapper)
          |> Enum.join()
          """,
          """
          a
          |> b()
          |> Enum.map_join(mapper)
          """
        )

        assert_style("a |> #{enum}.map(mapper) |> Enum.join(joiner)", "Enum.map_join(a, joiner, mapper)")
      end
    end

    test "map/into" do
      for enum <- ~w(Enum Stream) do
        assert_style("a|> #{enum}.map(b)|> Enum.into(%{})", "Map.new(a, b)")
        assert_style("a |> #{enum}.map(b) |> Enum.into(unk)", "Enum.into(a, unk, b)")

        assert_style(
          "a |> #{enum}.map(b) |> Enum.into(%{some: :existing_map})",
          "Enum.into(a, %{some: :existing_map}, b)"
        )

        assert_style(
          """
          # a
          # b
          a_multiline_mapper
          |> #{enum}.map(fn %{gets: shrunk, down: to_a_more_reasonable} ->
            # c
            IO.puts "woo!"
            # d
            {shrunk, to_a_more_reasonable}
          end)
          |> Enum.into(size)
          """,
          """
          # a
          # b
          Enum.into(a_multiline_mapper, size, fn %{gets: shrunk, down: to_a_more_reasonable} ->
            # c
            IO.puts("woo!")
            # d
            {shrunk, to_a_more_reasonable}
          end)
          """
        )

        for collectable <- ~W(Map Keyword MapSet), new = "#{collectable}.new" do
          assert_style("a |> #{enum}.map(b) |> Enum.into(#{new}())", "#{new}(a, b)")

          # Regression: something about the meta wants newlines when it's in a def
          assert_style(
            """
            def foo() do
              filename_map = foo |> Enum.map(&{&1.filename, true}) |> Enum.into(%{})
            end
            """,
            """
            def foo do
              filename_map = Map.new(foo, &{&1.filename, true})
            end
            """
          )
        end
      end
    end

    test "map/new" do
      for collectable <- ~W(Map Keyword MapSet), new = "#{collectable}.new" do
        assert_style("a |> Enum.map(b) |> #{new}()", "#{new}(a, b)")
      end
    end

    test "into(%{})" do
      assert_style("a |> Enum.into(%{}) |> b()", "a |> Map.new() |> b()")
      assert_style("a |> Enum.into(%{}, mapper) |> b()", "a |> Map.new(mapper) |> b()")
    end

    test "into(Collectable.new())" do
      assert_style("a |> Enum.into(foo) |> b()")
      assert_style("a |> Enum.into(foo, mapper) |> b()")

      for collectable <- ~W(Map Keyword MapSet), new = "#{collectable}.new" do
        assert_style("a |> Enum.into(#{new}) |> b()", "a |> #{new}() |> b()")
        assert_style("a |> Enum.into(#{new}, mapper) |> b()", "a |> #{new}(mapper) |> b()")

        assert_style(
          """
          a
          |> Enum.map(b)
          |> Enum.into(#{new}, c)
          """,
          """
          a
          |> Enum.map(b)
          |> #{new}(c)
          """
        )
      end
    end
  end

  describe "comments and..." do
    test "unpiping" do
      assert_style(
        """
        aliased =
          aliases
          |> MapSet.new(fn
            {:alias, _, [{:__aliases__, _, aliases}]} -> List.last(aliases)
            {:alias, _, [{:__aliases__, _, _}, [{_as, {:__aliases__, _, [as]}}]]} -> as
            # alias __MODULE__ or other oddities
            {:alias, _, _} -> nil
          end)

        excluded_first = MapSet.union(aliased, @excluded_namespaces)
        """,
        """
        aliased =
          MapSet.new(aliases, fn
            {:alias, _, [{:__aliases__, _, aliases}]} -> List.last(aliases)
            {:alias, _, [{:__aliases__, _, _}, [{_as, {:__aliases__, _, [as]}}]]} -> as
            # alias __MODULE__ or other oddities
            {:alias, _, _} -> nil
          end)

        excluded_first = MapSet.union(aliased, @excluded_namespaces)
        """
      )

      assert_style(
        """
        foo =
          # bar
          bar
          # baz
          |> baz(fn ->
            # a
            a
            # b
            b
          end)
        """,
        """
        # bar
        # baz
        foo =
          baz(bar, fn ->
            # a
            a
            # b
            b
          end)
        """
      )

      assert_style(
        """
        foo =
          # bar
          bar
          # baz



          |> baz(fn ->
            # a
            a
            # b
            b
          end)
        """,
        """
        # bar
        # baz
        foo =
          baz(bar, fn ->
            # a
            a
            # b
            b
          end)
        """
      )
    end

    test "optimizing" do
      assert_style(
        """
        a
        |> Enum.map(fn b ->
          c
          # a comment
          d
        end)
        |> Enum.join(x)
        |> Enum.each(...)
        """,
        """
        a
        |> Enum.map_join(x, fn b ->
          c
          # a comment
          d
        end)
        |> Enum.each(...)
        """
      )

      assert_style(
        """
        a
        |> Enum.map(fn b ->
          c
          # a comment
          d
        end)
        |> Enum.into(x)
        |> Enum.each(...)
        """,
        """
        a
        |> Enum.into(x, fn b ->
          c
          # a comment
          d
        end)
        |> Enum.each(...)
        """
      )

      assert_style(
        """
        a
        |> Enum.map(fn b ->
          c
          # a comment
          d
        end)
        |> Keyword.new()
        |> Enum.each(...)
        """,
        """
        a
        |> Keyword.new(fn b ->
          c
          # a comment
          d
        end)
        |> Enum.each(...)
        """
      )
    end
  end

  describe "pipifying" do
    test "no false positives" do
      pipe = "a() |> b() |> c()"
      assert_style pipe
      assert_style String.replace(pipe, " |>", "\n|>")
      assert_style "fn -> #{pipe} end"
      assert_style "if #{pipe}, do: ..."
      assert_style "x\n\n#{pipe}"
      assert_style "@moduledoc #{pipe}"
      assert_style "!(#{pipe})"
      assert_style "not foo(#{pipe})"
      assert_style ~s<"\#{#{pipe}}">
    end

    test "when it's not actually the first argument!" do
      assert_style """
      a
      |> M.f0(b |> M.f1() |> M.f2())
      |> M.f3()
      """
    end

    test "pipifying" do
      assert_style("e(d(a |> b |> c), f)", "a |> b() |> c() |> d() |> e(f)")

      assert_style(
        """
        # d
        d(
        # a
          a
          # b
          |> b
          # c
          |> c
        )
        """,
        """
        # d
        # a
        a
        # b
        |> b()
        # c
        |> c()
        |> d()
        """
      )
    end
  end

  describe "Req pipes" do
    @req2 for fun <- ~w(delete get head patch post put request run), bang <- ["", "!"], do: :"#{fun}#{bang}"

    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