(examples-for pp/breaker

("breaks 'if forms"
 (pp/breaker '(if a b c d e))
 ((if a) (b) (c) (d) (e)))

("breaks 'let forms"
 (pp/breaker '(let a b c d))
 ((let a b) (c) (d)))

("breaks 'def forms"
 (pp/breaker '(def yoyo (x y) a b))
 ((def yoyo (x y)) (a) (b))))

(examples-for pp/dotify

("nothing"
 (pp/dotify nil)
 nil)

("atom"
 (inspect:pp/dotify 'a)
 "a")

("plain list"
 (inspect:pp/dotify '(a b c))
 "(a b c)")

("dotted list"
 (map inspect (pp/dotify '(a b c . d)))
 ("a" "b" "c" "." "d"))

("nested dotted list"
 (inspect:pp/dotify '(def foo (a b c . d)
                       (a (fn (x y . z) (d z) ))))
 "(def foo (a b c . d) (a (fn (x y . z) (d z))))"))

(examples-for pp/indent

("nothing"
 (pp/indent nil (list " "))
 (" "))

("number"
 (pp/indent 22 (list " "))
 ("   " " "))

("string"
 (pp/indent "forty-two" (list " "))
 ("          " " "))

("symbol"
 (pp/indent 'forty-two (list " "))
 ("          " " "))

("list"
 (pp/indent '(fn (x) (blow x)) (list " "))
 (" ")))

(examples-for pp/cleanup

("empty"
 (pp/cleanup "")
 "")

("atom"
 (pp/cleanup "foo")
 "foo")

("already clean"
 (pp/cleanup "foo\nbar")
 "foo

bar“)

("removes trailing whitespace on each line"
 (pp/cleanup "foo  \nbar   \ntoto    ")
 "foo

bar toto“)

("removes trailing whitespace on each line but preserves leading whitespace"
 (pp/cleanup "foo  \n  bar   \n   toto    ")
 "foo
bar
 toto"))

(examples-for pp/unsyntax

("nil"
 (to-string:pp/unsyntax nil)
 "")

("atom"
 (to-string:pp/unsyntax 42)
 "42")

("list"
 (to-string:pp/unsyntax '(for a 1 10 (p 'hello 'world)))
 "(for a 1 10 (p 'hello 'world))")

("list with embedded syntax"
 (to-string:pp/unsyntax '(for (colon-syntax a b) 1 10 ((dot-syntax p q) 'hello 'world)))
 "(for a:b 1 10 (p.q 'hello 'world))")

("percent-syntax"
 (to-string:pp/unsyntax '(percent-syntax this that))
 "this%that")

("prefix percent-syntax"
 (to-string:pp/unsyntax '(percent-syntax || that))
 "%that")

("postfix percent-syntax"
 (to-string:pp/unsyntax '(percent-syntax this ||))
 "this%")

("postfix multiple percent-syntax"
 (to-string:pp/unsyntax '(percent-syntax this that || another))
 "this%that%%another")

("nested syntax"
 (to-string:pp/unsyntax '(percent-syntax this (ampersand-syntax x y) that))
 "this%x&y%that"))

(examples-for pp/split-form

("first item"
 (pp/split-form '(a b c d) 1)
 ((a) (b) (c) (d)))

("first two items"
 (pp/split-form '(a b c d e) 2)
 ((a b) (c) (d) (e)))

("first three items"
 (pp/split-form '(a b c d e f) 3)
 ((a b c) (d) (e) (f))))

(examples-for pp/flatly

("nil"
 (pp/flatly nil)
 "nil")

("number"
 (pp/flatly 22)
 "22")

("symbol"
 (pp/flatly 'qwerty)
 "qwerty")

("list"
 (pp/flatly '(a b c d 21 22 23 'quoting) )
 "(a b c d 21 22 23 'quoting)")

("macro example"
 (pp/flatly '(mac johnny (foo bar) `(this ,foo ,@(map twisty bar))))
 "(mac johnny (foo bar) `(this ,foo ,@(map twisty bar)))"))

(examples-for pp

("a quote"
 (pp '(quote a))
 "'a")

("unquote"
 (pp '(unquote a))
 ",a")

("unquote-splicing"
 (pp '(unquote-splicing a))
 ",@a")

("quasiquote"
 (pp '(quasiquote a))
 "`a")

("quote unquote"
 (pp '(quote (unquote a)))
 "',a")

("a macro invocation"
 (pp '(mac pp/def (name args . body) `(hash-set pp/special-forms ',name (fn ,args ,@body))))
 "(mac pp/def (name args . body)
   `(hash-set pp/special-forms
              ',name
              (fn ,args ,@body)))")

("a 'def invocation"
 (pp '(def pp (form) (pp/main form 0)))
 "(def pp (form) (pp/main form 0))")

("a longer 'def invocation"
 (pp '(def pp (form)
        (pp/main form 0)
        (pp/again form 1)
        (pp/more (jump:skip form) 2)))
 "(def pp (form)
   (pp/main form 0)
   (pp/again form 1)
   (pp/more (jump:skip form) 2))")

("a 'def with a dotted argument list"
 (pp '(def afun (a b c . others)
        (afun a b c (a (car others) (b (cdr others))))))
 "(def afun (a b c . others)
   (afun a
         b
         c
         (a (car others) (b (cdr others)))))")

("something with a plain string literal"
 (pp '(def yoohoo (it) (wrangle "foobar" it)))
 "(def yoohoo (it) (wrangle \"foobar\" it))")

("something with a nil and t literal"
 (pp '(def yoohoo (it) (wrangle nil t it)))
 "(def yoohoo (it) (wrangle nil t it))")

("a 'let form squished into one line"
 (pp '(let acc nil (rfnwith flattenize (x things) (if (pair? x) (eachr flattenize x) (push x acc))) acc))
 "(let acc nil
   (rfnwith flattenize (x things)
            (if (pair? x)
                (eachr flattenize x)
                (push x acc)))
   acc)")

("a real-life example from utils with improper 'if formatting"
 (pp '(def flatten (things)
        (let acc nil
          (rfnwith flattenize (x things)
                   (if (pair? x) (eachr flattenize x) (push x acc)))
          acc)))
 "(def flatten (things)
   (let acc nil
        (rfnwith flattenize (x things)
                 (if (pair? x)
                     (eachr flattenize x)
                     (push x acc)))
        acc))")

("a real-life example from utils"
 (pp '(def list-slices (things slice-size)
        ; slice 'things into a list of lists each with maximum 'slice-size items
        (chapter pagination list-management)
        (if (< (len things) slice-size)
            (cons things nil)
            (cons (firstn slice-size things)
                  (list-slices (nthcdr slice-size things)
                               slice-size)))))
 "(def list-slices (things slice-size)
   ; slice 'things into a list of lists each with maximum 'slice-size items
   (chapter pagination list-management)
   (if (< (len things) slice-size)
       (cons things nil)
       (cons (firstn slice-size things)
             (list-slices (nthcdr slice-size things)
                          slice-size))))")

("a real-life example from test-runner"
 (pp '(def run-all-tests (verbose)
        ; runs all tests that have been registered with 'register-test
        (with (passed 0 failed 0)
              (with (f-pass (fn nil (assign passed (+ 1 passed)))
                            f-fail (fn nil (assign failed (+ 1 failed))))
                    (run-tests `(suite "all tests" ,@all-tests) f-pass f-fail verbose)
                    (p "passed: " passed)
                    (p "failed: " failed)
                    (/ passed (+ passed failed))))))
 "(def run-all-tests (verbose)
   ; runs all tests that have been registered with 'register-test
   (with (passed 0 failed 0)
         (with (f-pass (fn nil (assign passed (+ 1 passed)))
                f-fail (fn nil (assign failed (+ 1 failed))))
               (run-tests `(suite \"all tests\" ,@all-tests)
                          f-pass
                          f-fail
                          verbose)
               (p \"passed: \" passed)
               (p \"failed: \" failed)
               (/ passed (+ passed failed)))))")

("special syntax"
 (pp '(string-pieces "hello " (bang-syntax || (dot-syntax x y (ampersand-syntax foo bar))) " and welcome to " (prefix-list "%%" (a b c d)) " and friends!"))
 "\"hello ~~|!x.y.foo&bar| and welcome to ~~%%(a b c d) and friends!\"")

("percent-syntax"
 (pp '(percent-syntax || (dot-syntax x y)))
 "%x.y")

("percent-syntax with args"
 (pp '(%tr.klakla
           (%td:otherkla:joinstr ", " (map &firstname ppl))
           (%td:otherkla:joinstr ", " (map &email ppl))))
 "(%tr.klakla
(%td:otherkla:joinstr
  \", \"
  (map &firstname ppl))
(%td:otherkla:joinstr
  \", \"
  (map &email ppl)))")

("brace list"
 (pp '(let hello {a 1 b "two" c 'three d ,four e (sub invocation) f {sub brace list here} }))

“(let hello { a 1

b \"two\"
c 'three
d ,four
e (sub invocation)
f { sub brace
  list here } })"))