Ensure doc_line resets algebra formatting line buffer, closes #2014

Author: José Valim

lib/elixir/lib/inspect/algebra.ex

@@ -73,7 +73,7 @@ defmodule Inspect.Algebra do
 
   # Functional interface to `doc` records
 
-  @type t :: :doc_nil | doc_cons_t | doc_nest_t | doc_break_t | doc_group_t | binary
+  @type t :: :doc_nil | :doc_line | doc_cons_t | doc_nest_t | doc_break_t | doc_group_t | binary
   defrecordp :doc_cons, left: :doc_nil :: t, right: :doc_nil :: t
   defrecordp :doc_nest, indent: 1 :: non_neg_integer, doc: :doc_nil :: t
   defrecordp :doc_break, str: " " :: binary
@@ -94,7 +94,7 @@ defmodule Inspect.Algebra do
   defp do_is_doc(doc) do
     quote do
       is_binary(unquote(doc)) or
-      unquote(doc) == :doc_nil or
+      unquote(doc) in [:doc_nil, :doc_line] or
       (is_tuple(unquote(doc)) and
        elem(unquote(doc), 0) in [:doc_cons, :doc_nest, :doc_break, :doc_group])
     end
@@ -274,7 +274,7 @@ defmodule Inspect.Algebra do
 
   """
   @spec line(t, t) :: doc_cons_t
-  def line(x, y), do: concat(x, concat(@newline, y))
+  def line(x, y), do: concat(x, concat(:doc_line, y))
 
   @doc """
   Folds a list of document entities into a document entity
@@ -397,6 +397,7 @@ defmodule Inspect.Algebra do
   @spec fits?(integer, [{ integer, mode, t }]) :: boolean
   def fits?(w, _) when w < 0,                               do: false
   def fits?(_, []),                                         do: true
+  def fits?(_, [{_, _, :doc_line} | _]),                    do: true
   def fits?(w, [{_, _, :doc_nil} | t]),                     do: fits?(w, t)
   def fits?(w, [{i, m, doc_cons(left: x, right: y)} | t]),  do: fits?(w, [{i, m, x} | [{i, m, y} | t]])
   def fits?(w, [{i, m, doc_nest(indent: j, doc: x)} | t]),  do: fits?(w, [{i + j, m, x} | t])
@@ -408,6 +409,7 @@ defmodule Inspect.Algebra do
   @doc false
   @spec format(integer | :infinity, integer, [{ integer, mode, t }]) :: [binary]
   def format(_, _, []),                                        do: []
+  def format(w, _, [{i, _, :doc_line} | t]),                   do: [indent(i) | format(w, i, t)]
   def format(w, k, [{_, _, :doc_nil} | t]),                    do: format(w, k, t)
   def format(w, k, [{i, m, doc_cons(left: x, right: y)} | t]), do: format(w, k, [{i, m, x} | [{i, m, y} | t]])
   def format(w, k, [{i, m, doc_nest(indent: j, doc: x)} | t]), do: format(w, k, [{i + j, m, x} | t])
@@ -420,11 +422,13 @@ defmodule Inspect.Algebra do
     if w == :infinity or fits?(w - k, t) do
       [s | format(w, k, t)]
     else
-      prefix = :binary.copy(" ", i)
-      [@newline, prefix | format(w, i, t)]
+      [indent(i) | format(w, i, t)]
     end
   end
 
+  defp indent(0), do: @newline
+  defp indent(i), do: @newline <> :binary.copy(" ", i)
+
   @doc false
   @spec render([binary]) :: binary
   def render(sdoc) do

lib/elixir/test/elixir/inspect/algebra_test.exs

@@ -17,94 +17,93 @@ defmodule Inspect.AlgebraTest do
 
   def factor(doc, w), do: format(w, 0, [{0, :flat, group(doc)}])
 
-  test :empty do
+  test "empty doc" do
     # Consistence with definitions
     assert empty == :doc_nil
+
     # Consistence of corresponding sdoc
     assert factor(empty, 80) == []
+
     # Consistent formatting
     assert pretty(empty, 80) == ""
   end
 
-  test :break do
+  test "break doc" do
     # Consistence with definitions
-    ## Normal case
     assert break("break") == { :doc_break, "break" }
-    ## Degeneracy
     assert break("") == { :doc_break, "" }
-    ## ong argument type
+
+    # Wrong argument type
     assert_raise FunctionClauseError, fn -> break(42) end
+
     # Consistence of corresponding sdoc
     assert factor(break("_"), 80) == ["_"]
+
     # Consistent formatting
     assert pretty(break("_"), 80) == "_"
   end
 
-  test :glue do
+  test "glue doc" do
     # Consistence with definitions
     assert glue("a", "->", "b") == { :doc_cons,
       "a", { :doc_cons, { :doc_break, "->" }, "b" }
     }
     assert glue("a", "b") == glue("a", " ", "b")
 
-    ## Wrong argument type
+    # Wrong argument type
     assert_raise FunctionClauseError, fn -> glue("a", 42, "b") end
   end
 
-  test :text do
-    # Consistence of corresponding docfactor
+  test "text doc" do
+    # Consistence of corresponding sdoc
     assert factor("_", 80) == ["_"]
+
     # Consistent formatting
     assert pretty("_", 80) == "_"
   end
 
-  test :space do
+  test "space doc" do
     # Consistency with definitions
     assert space("a", "b") == { :doc_cons,
       "a", { :doc_cons, " ", "b" }
     }
   end
 
-  test :nest do
+  test "nest doc" do
     # Consistence with definitions
-    ## Normal case
     assert nest(empty, 1) == { :doc_nest, 1, empty }
-    ## Degeneracy
     assert nest(empty, 0) == :doc_nil
-    ## ong argument type
+
+    # Wrong argument type
     assert_raise FunctionClauseError, fn -> nest("foo", empty) end
 
-    a1   = fn -> nest("a", 1) end
-    alb1 = fn -> nest(glue("a", "b"), 1) end
     # Consistence of corresponding sdoc
-    ## Trivial case
-    assert factor(a1.(), 80)  == ["a"]
-    ## Correctly indenting line forcing linebreak
-    assert format(2, 0, [{0, :break, alb1.()}]) == ["a", "\n", " ", "b"]
+    assert factor(nest("a", 1), 80)  == ["a"]
+    assert format(2, 0, [{0, :break, nest(glue("a", "b"), 1)}]) == ["a", "\n ", "b"]
 
     # Consistent formatting
-    ## Trivial case
-    assert pretty(a1.(), 80) == "a"
-    ## Correctly indenting line
-    assert render(format 2, 0, [{0, :break, alb1.()}]) == "a\n b"
+    assert pretty(nest("a", 1), 80) == "a"
+    assert render(format 2, 0, [{0, :break, nest(glue("a", "b"), 1)}]) == "a\n b"
   end
 
-  test :infinity do
-    # w = :infinity should disable pretty printer
-    s = String.duplicate "x", 50
-    g = ";"
-    big_document = group(glue(s, g, s) |>  glue(g, s) |>  glue(g, s) |> glue(g, s))
+  test "line doc" do
+    # Consistency with definitions
+    assert line("a", "b") ==
+      { :doc_cons, "a", { :doc_cons, :doc_line, "b" } }
+
+    # Consistence of corresponding sdoc
+    assert factor(line("a", "b"), 1) == ["a", "\n", "b"]
+    assert factor(line("a", "b"), 9) == ["a", "\n", "b"]
 
-    assert pretty(big_document, :infinity) == s <> g <> s <> g <> s <> g <> s <> g <> s
+    # Consistent formatting
+    assert pretty(line(glue("aaa", "bbb"), glue("ccc", "ddd")), 10) ==
+           "aaa bbb\nccc ddd"
   end
 
-  test :group do
+  test "group doc" do
     # Consistency with definitions
-    ## Normal case
     assert group(glue("a", "b")) ==
       { :doc_group, { :doc_cons, "a", concat(break, "b") }}
-
-    ## Degeneracy
     assert group(empty) == { :doc_group, empty }
 
     # Consistence of corresponding sdoc
@@ -115,4 +114,12 @@ defmodule Inspect.AlgebraTest do
     assert pretty(helloabcd, 5) == "hello\na b\ncd"
     assert pretty(helloabcd, 80) == "hello a b cd"
   end
+
+  test "formatting with infinity" do
+    s = String.duplicate "x", 50
+    g = ";"
+    doc = group(glue(s, g, s) |>  glue(g, s) |>  glue(g, s) |> glue(g, s))
+
+    assert pretty(doc, :infinity) == s <> g <> s <> g <> s <> g <> s <> g <> s
+  end
 end