#pretty-fast-pretty-printer

#Installing

moon add marianoguerra/pretty-fast-pretty-printer

import {
  "marianoguerra/pretty-fast-pretty-printer" @pp,
}

#What it is for

///|
test {
  let cond = txt("x > 0")
  let body = txt("print(x)")
  let doc = vert([
    horz([txt("while ("), cond, txt(") {")]),
    horz([txt("  "), body]),
    txt("}"),
  ])
  inspect(
    doc.display_string(width=80),
    content=(
      #|while (x > 0) {
      #|  print(x)
      #|}
    ),
  )
}

#The four combinators

///|
test {
  inspect(
    vert([txt("Hello,"), txt("world!")]).display_string(),
    content=(
      #|Hello,
      #|world!
    ),
  )
}

///|
test {
  let doc = horz([txt("BEGIN "), vert([txt("first line"), txt("second line")])])
  inspect(
    doc.display_string(),
    content=(
      #|BEGIN first line
      #|      second line
    ),
  )
}

///|
test {
  let doc = if_flat(
    txt("[1, 2, 3]"),
    vert([txt("[1,"), txt(" 2,"), txt(" 3]")]),
  )
  inspect(doc.display_string(width=20), content="[1, 2, 3]")
  inspect(
    doc.display_string(width=5),
    content=(
      #|[1,
      #| 2,
      #| 3]
    ),
  )
}

///|
test {
  let flat = txt("[1, 2]")
  let broken = vert([txt("[1,"), txt(" 2]")])
  // The group fits in seven columns, so it stays flat and the `))` overflows.
  inspect(
    horz([if_flat(flat, broken), txt("))")]).display_string(width=7),
    content="[1, 2]))",
  )
  // Told that two more columns follow, it breaks instead.
  inspect(
    horz([if_flat(flat, broken, reserve=2), txt("))")]).display_string(width=7),
    content=(
      #|[1,
      #| 2]))
    ),
  )
}

#The rest of the API

///|
test {
  let given = vert([txt("first line"), txt("second line")])
  inspect(
    nest(2, given).display_string(),
    content=(
      #|first line
      #|  second line
    ),
  )
  inspect(
    horz([txt("  "), given]).display_string(),
    content=(
      #|  first line
      #|  second line
    ),
  )
}

#Capping indentation

///|
test {
  let doc = horz([txt("(let ((x "), vert([txt("first"), txt("second")])])
  assert_eq(doc.display(), ["(let ((x first", "         second"])
  assert_eq(doc.display(max_indent=4), ["(let ((x first", "    second"])
}

#Measuring text that is not plain ASCII

///|
test {
  // A CJK character is one UTF-16 unit but occupies two columns.
  assert_eq(txt_as("世界", 4).flat_width(), Some(4))
  // An ANSI colour escape is five UTF-16 units and occupies none, so a
  // syntax-highlighted document lays out exactly like the plain one.
  let red = txt_as("\u{1b}[31m", 0)
  let reset = txt_as("\u{1b}[0m", 0)
  assert_eq(horz([red, txt("hello"), reset]).flat_width(), Some(5))
}

#Text whose layout is already decided

///|
test {
  inspect(
    horz([txt("x = "), txt_lines("a\nb")]).display_string(),
    content=(
      #|x = a
      #|    b
    ),
  )
  inspect(
    horz([txt("x = "), txt_raw("a\nb")]).display_string(),
    content=(
      #|x = a
      #|b
    ),
  )
}

#Building documents from templates

///|
test {
  let c = txt("a == b")
  let t = txt("a << 2")
  let e = txt("a + b")
  let doc = pretty([
    Str("if ("),
    Val(c),
    Str(") {\n  "),
    Val(t),
    Str("\n} else {\n  "),
    Val(e),
    Str("\n}"),
  ])
  inspect(
    doc.display_string(),
    content=(
      #|if (a == b) {
      #|  a << 2
      #|} else {
      #|  a + b
      #|}
    ),
  )
}

#Utility constructors

///|
test {
  let words = ["This", "is", "a", "sentence", "with", "eight", "words"].map(txt)
  inspect(
    wrap(words).display_string(width=20),
    content=(
      #|This is a sentence
      #|with eight words
    ),
  )
}

///|
test {
  let doc = sep_by(["alpha", "beta", "gamma"].map(txt), sep=", ", vert_sep=",")
  inspect(doc.display_string(width=40), content="alpha, beta, gamma")
  inspect(
    doc.display_string(width=10),
    content=(
      #|alpha,
      #|beta,
      #|gamma
    ),
  )
}

///|
test {
  let doc = begin_like_sexpr(txt("begin"), [
    standard_sexpr(txt("+"), [txt("1"), txt("2")]),
    standard_sexpr(txt("display"), [txt("a-fairly-long-variable-name")]),
  ])
  inspect(
    doc.display_string(width=30),
    content=(
      #|(begin
      #|  (+ 1 2)
      #|  (display
      #|   a-fairly-long-variable-name))
    ),
  )
}

#Differences from the JavaScript version

• No variadic functions, so horz, vert and concat take an Array[Doc] rather than a spread of arguments. The horzArray / vertArray / concatArray variants are therefore unnecessary and do not exist.
• No implicit coercion. JavaScript accepts a bare string (or any object with a .pretty() method) anywhere a document is expected; here you write txt("..."). Give your own types a to_doc method and call it.
• The pretty`...` tagged template becomes pretty([Str(...), Val(...)]).
• txt panics on embedded newlines instead of throwing, and concat([]) returns empty instead of raising.
• parens is public here; upstream keeps it internal.
• txt measures widths in UTF-16 code units, as in JavaScript, which is exact for ASCII source code. Unlike upstream, txt_as lets you override that when it is not.
• nest, txt_as, txt_raw, flat_width, write_to, if_flat's reserve and the horz2 / vert2 / concat2 forms have no upstream equivalent.

#Running it

moon test          # unit tests, including the ported upstream suite
moon run cmd/main  # a small s-expression printer, shown at three widths

#License