pp-grid.api — org.clojars.rorokimdim/pp-grid 0.1.17

++ clj

(++ & gs)

Convenience wrapper for add to accept grids as args.

-- clj

(-- & gs)

Convenience wrapper for subtract to accept grids as args.

=== clj

(=== x-padding & grids)

Horizontally aligns given grids with some defaults.

Just a convenience wrapper for halign to accept grids as args and use some default values for padding and centering.

add clj

(add & gs)

Constructs a grid with all given grids added together.

arrow-down clj

(arrow-down n)

(arrow-down n body-char)

(arrow-down n body-char head-char)

Constructs a down arrow of given length.

For example, (arrow-down 4) is │ │ │ ▼

arrow-left clj

(arrow-left n)

(arrow-left n body-char)

(arrow-left n body-char head-char)

Constructs a left arrow of given length.

For example, (arrow-left 4) is '◀───'.

arrow-left-right clj

(arrow-left-right n)

(arrow-left-right n body-char)

(arrow-left-right n body-char left-head-char right-head-char)

Constructs a left-right arrow of given length.

For example, (arrow-left-right 4) is '◀──▶︎'.

arrow-ne clj

(arrow-ne n)

(arrow-ne n body-char)

(arrow-ne n body-char start-char end-char)

Constructs an arrow pointing north-east of given length.

For example, (arrow-ne 4) is * / / /

arrow-nw clj

(arrow-nw n)

(arrow-nw n body-char)

(arrow-nw n body-char start-char end-char)

Constructs an arrow pointing north-west of given length.

For example, (arrow-nw 4) is -- ignore the double lines. Can't put it here without escaping it! *

\

arrow-right clj

(arrow-right n)

(arrow-right n body-char)

(arrow-right n body-char head-char)

Constructs a right arrow of given length.

For example, (arrow-right 4) is '───▶︎'.

arrow-se clj

(arrow-se n)

(arrow-se n body-char)

(arrow-se n body-char start-char end-char)

Constructs an arrow pointing south-east of given length.

For example, (arrow-se 4) is -- ignore the double lines. Can't put it here without escaping it!


*

arrow-sw clj

(arrow-sw n)

(arrow-sw n body-char)

(arrow-sw n body-char start-char end-char)

Constructs an arrow pointing south-west of given length.

For example, (arrow-sw 4) is / / / *

arrow-up clj

(arrow-up n)

(arrow-up n body-char)

(arrow-up n body-char head-char)

Constructs an up arrow of given length.

For example, (arrow-up 4) is ▲ │ │ │

arrow-up-down clj

(arrow-up-down n)

(arrow-up-down n body-char)

(arrow-up-down n body-char up-head-char down-head-char)

Constructs a up-down arrow of given length.

For example, (arrow-up-down 4) is ▲ │ │ ▼

box clj

(box g
     &
     {:keys [left-padding right-padding top-padding bottom-padding
             left-border-char right-border-char top-border-char
             bottom-border-char top-left-corner-char top-right-corner-char
             bottom-left-corner-char bottom-right-corner-char fill-escape-codes]
      :or {top-right-corner-char \+
           top-padding 0
           top-border-char \-
           bottom-border-char \-
           left-border-char \|
           right-border-char \|
           bottom-left-corner-char \+
           bottom-padding 0
           right-padding 0
           left-padding 0
           bottom-right-corner-char \+
           top-left-corner-char \+}
      :as provided-opts})

Constructs a grid wrapping given grid (or a string-convertible value) into a box.

For example, (box (text "HELLO")) is +-----+ |HELLO| +-----+

box0 clj

(box0 g
      &
      {:keys [left-padding right-padding top-padding bottom-padding
              fill-escape-codes]
       :or {left-padding 0 right-padding 0 top-padding 0 bottom-padding 0}})

Constructs a grid wrapping given grid into a border-less box.

For example, (box0 (text "HELLO")) is

HELLO

box1 clj

(box1 g
      &
      {:keys [left-padding right-padding top-padding bottom-padding
              fill-escape-codes]
       :or {left-padding 0 right-padding 0 top-padding 0 bottom-padding 0}})

Constructs a grid wrapping given grid into a box.

Similar to box, but uses different border.

For example, (box1 (text "HELLO")) is ┌─────┐ │HELLO│ └─────┘

box2 clj

(box2 g
      &
      {:keys [left-padding right-padding top-padding bottom-padding
              fill-escape-codes]
       :or {left-padding 0 right-padding 0 top-padding 0 bottom-padding 0}})

Constructs a grid wrapping given grid into a box.

Similar to box, but uses border with rounded corners.

For example, (box2 (text "HELLO")) is ╭─────╮ │HELLO│ ╰─────╯

box3 clj

(box3 g
      &
      {:keys [left-padding right-padding top-padding bottom-padding
              fill-escape-codes]
       :or {left-padding 0 right-padding 0 top-padding 0 bottom-padding 0}})

Constructs a grid wrapping given grid into a box.

Similar to box, but uses different border.

For example, (box3 (text "HELLO")) is ╒═════╕ │HELLO│ ╘═════╛

box4 clj

(box4 g
      &
      {:keys [left-padding right-padding top-padding bottom-padding
              fill-escape-codes]
       :or {left-padding 0 right-padding 0 top-padding 0 bottom-padding 0}})

Constructs a grid wrapping given grid into a box.

Similar to box, but uses different border.

For example, (box4 (text "HELLO")) is ╒═════╕ │HELLO│ ╘═════╛

box5 clj

(box5 g
      &
      {:keys [left-padding right-padding top-padding bottom-padding
              fill-escape-codes]
       :or {left-padding 0 right-padding 0 top-padding 0 bottom-padding 0}})

Constructs a grid wrapping given grid into a box.

Similar to box, but uses '*' for all border characters.

For example, (box5 (text "HELLO")) is

---

HELLO

---

chart-bar clj

(chart-bar ns
           &
           {:keys [labels max-length bar-symbol horizontal]
            :or {labels ns horizontal true}})

Constructs a bar chart.

For example, (chart-bar [10 20 30 40]) is ■■■■■■■■■■■■■ 10 ■■■■■■■■■■■■■■■■■■■■■■■■■■■ 20 ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 30 ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 40

chart-xy clj

(chart-xy xs
          ys
          &
          {:keys [point-symbol draw-axis x-label y-label max-width max-height]
           :or {point-symbol \*
                draw-axis true
                x-label "x"
                y-label "y"
                max-width 40
                max-height 10}})

Constructs a xy-chart (scatter plot).

For example, (chart-xy (range) [0 1 2 1 0 1 2 1 0] :max-height 2 :max-width 10) is y ▲ | | * * |* * * * --------*-▶ x

decorate clj

(decorate x escape-code & escape-codes)

Decorates a grid or a string-convertible value with given ansi-escape-codes.

empty-grid clj

(empty-grid)

(empty-grid dimension)

ESCAPE-CODE-BACKGROUND-BLACK clj

ESCAPE-CODE-BACKGROUND-BLUE clj

ESCAPE-CODE-BACKGROUND-BRIGHT-BLACK clj

ESCAPE-CODE-BACKGROUND-BRIGHT-BLUE clj

ESCAPE-CODE-BACKGROUND-BRIGHT-CYAN clj

ESCAPE-CODE-BACKGROUND-BRIGHT-GREEN clj

ESCAPE-CODE-BACKGROUND-BRIGHT-MAGENTA clj

ESCAPE-CODE-BACKGROUND-BRIGHT-RED clj

ESCAPE-CODE-BACKGROUND-BRIGHT-WHITE clj

ESCAPE-CODE-BACKGROUND-BRIGHT-YELLOW clj

ESCAPE-CODE-BACKGROUND-CYAN clj

ESCAPE-CODE-BACKGROUND-GREEN clj

ESCAPE-CODE-BACKGROUND-MAGENTA clj

ESCAPE-CODE-BACKGROUND-RED clj

ESCAPE-CODE-BACKGROUND-WHITE clj

ESCAPE-CODE-BACKGROUND-YELLOW clj

ESCAPE-CODE-BLACK clj

ESCAPE-CODE-BLUE clj

ESCAPE-CODE-BOLD clj

ESCAPE-CODE-BRIGHT-BLACK clj

ESCAPE-CODE-BRIGHT-BLUE clj

ESCAPE-CODE-BRIGHT-CYAN clj

ESCAPE-CODE-BRIGHT-GREEN clj

ESCAPE-CODE-BRIGHT-MAGENTA clj

ESCAPE-CODE-BRIGHT-RED clj

ESCAPE-CODE-BRIGHT-WHITE clj

ESCAPE-CODE-BRIGHT-YELLOW clj

ESCAPE-CODE-CYAN clj

ESCAPE-CODE-GREEN clj

ESCAPE-CODE-MAGENTA clj

ESCAPE-CODE-RED clj

ESCAPE-CODE-RESET clj

ESCAPE-CODE-REVERSED clj

ESCAPE-CODE-UNDERLINE clj

ESCAPE-CODE-WHITE clj

ESCAPE-CODE-YELLOW clj

fill clj

(fill w h)

(fill w h c)

Constructs a filler of given width and height.

For example, (fill 4 4 *) is

---

---

---

---

grid? clj

(grid? x)

halign clj

(halign grids)

(halign grids x-padding)

(halign grids x-padding center?)

Constructs a grid containing given grids aligned horizontally.

For example, (halign [(text "A") (text "B") (text "C")]) is ABC.

height clj

(height x)

hfill clj

(hfill n)

(hfill n c)

Constructs a horizontal-filler of given size.

For example, (hfill 3 *) is '***'.

hline clj

(hline n)

(hline n body-char)

(hline n body-char start-char end-char)

Constructs a horizontal line of given length.

For example, (hline 3) is '---'.

hspacer clj

(hspacer n)

Constructs a horizontal space of given length.

For example, (hspacer 5) is " ".

matrix clj

(matrix ks rows)

(matrix ks rows header?)

Constructs a matrix.

Similar to table, but changes the border to make it look more like a matrix.

For example, (matrix [:a :b] [{:a 1 :b 2} {:a 3 :b 4}]) is ╭ ╮ │ :a :b │ │ │ │ 1 2 │ │ 3 4 │ ╰ ╯

paragraph clj

(paragraph s)

(paragraph s padding)

(paragraph s pad-left pad-right)

(paragraph s pad-left pad-right max-width)

(paragraph s pad-left pad-right max-width first-line-indent)

Constructs a grid containing a paragraph of text.

By default paragraphs have max-width of 80 chars. If any word is longer than max-width chars, it will appear alone in a line without being truncated.

pull clj

(pull g dx dy)

Pulls a grid by given amounts horizontally and vertically.

Just a convenience function for transforming with tf-translate. Useful for tweaking alignments.

render clj multimethod

render-grid clj multimethod

spacer clj

(spacer width height)

Constructs a rectangular space of given width and height.

subtract clj

(subtract & gs)

Returns the first grid minus keys in rest of the grids.

table clj

(table ks
       rows
       &
       {:keys [nsew-char nse-char nsw-char ewn-char ews-char ns-char ew-char
               nw-char ne-char se-char sw-char align header? row-decorations]
        :or {ns-char \|
             ews-char \+
             nse-char \+
             ew-char \-
             align :right
             ne-char \+
             nw-char \+
             nsw-char \+
             header? true
             se-char \+
             ewn-char \+
             sw-char \+
             nsew-char \+}})

Constructs a table.

Produces similar table as clojure.pprint/print-table.

Adapted from source-code of clojure.pprint/print-table.

For example, (table [:a :b] [{:a 1 :b 2} {:a 3 :b 4}]) is +----+----+ | :a | :b | +----+----+ | 1 | 2 | | 3 | 4 | +----+----+

row-decorations keyword-argument can be provided. It is a sequence of ansi-escape codes. If header? is true, the header will be decorated with the first ansi-escape code in row-decorations. And the other rows will be decorated with the rest -- if there aren't enough, we'll just cycle over the given ansi-escape-codes. For example, try (table [:a :b] [{:a 1 :b 2} {:a 3 :b 4}] :row-decorations [ESCAPE-CODE-BACKGROUND-BRIGHT-GREEN ESCAPE-CODE-BACKGROUND-BRIGHT-MAGENTA ESCAPE-CODE-BACKGROUND-BLUE])

table* clj

(table* grids n)

Constructs a n-column, border-less, header-less table with given grids.

Just a convenience wrapper around table0. For more customization, use table0 or table functions.

table0 clj

(table0 ks rows)

(table0 ks rows header?)

(table0 ks rows header? align)

(table0 ks rows header? align row-decorations)

Constructs a border-less table.

For example, (table0 [:a :b] [{:a 1 :b 2} {:a 3 :b 4}]) is

:a :b

1 2 3 4

Rows can be decorated with row-decorations argument, which is a sequence of ansi-escape-codes. Please see docstring for table.

table1 clj

(table1 ks rows)

(table1 ks rows header?)

(table1 ks rows header? align)

(table1 ks rows header? align row-decorations)

Constructs a table.

Similar to table but uses different border.

For example, (table1 [:a :b] [{:a 1 :b 2} {:a 3 :b 4}]) is ┌────┬────┐ │ :a │ :b │ ├────┼────┤ │ 1 │ 2 │ │ 3 │ 4 │ └────┴────┘

Rows can be decorated with row-decorations argument, which is a sequence of ansi-escape-codes. Please see docstring for table.

table2 clj

(table2 ks rows)

(table2 ks rows header?)

(table2 ks rows header? align)

(table2 ks rows header? align row-decorations)

Constructs a table.

Similar to table but uses different border (rounded corners).

For example, (table2 [:a :b] [{:a 1 :b 2} {:a 3 :b 4}]) is ╭────┬────╮ │ :a │ :b │ ├────┼────┤ │ 1 │ 2 │ │ 3 │ 4 │ ╰────┴────╯

Rows can be decorated with row-decorations argument, which is a sequence of ansi-escape-codes. Please see docstring for table.

table3 clj

(table3 ks rows)

(table3 ks rows header?)

(table3 ks rows header? align)

(table3 ks rows header? align row-decorations)

Constructs a table.

Similar to table but uses dotted border.

For example, (table3 [:a :b] [{:a 1 :b 2} {:a 3 :b 4}]) is ........... : :a : :b : ..........: : 1 : 2 : : 3 : 4 : :....:....:

Rows can be decorated with row-decorations argument, which is a sequence of ansi-escape-codes. Please see docstring for table.

text clj

(text s)

(text s padding)

(text s pad-left pad-right)

(text s pad-left pad-right pad-char)

Constructs a grid containing given string.

If s is not a string, then (str s) will be used.

Each line in the string is put in a new row.

tf-hflip clj

(tf-hflip)

Returns a function that horizontally flips a coordinate.

Returns a function just to keep it consistent with other tf-* functions.

For example, ((tf-hflip) [1 2]) = [-1 2].

tf-project clj

(tf-project target-dimension)

(tf-project target-dimension project-fn)

Returns a function that projects a coordinate into given dimension.

For example, ((tf-project 2) [1 2 3 4 5]) = [1 2].

A project-fn can be passed in to change how a coordinate is projected. By default, the identity function is used.

tf-rotate clj

(tf-rotate radians)

Returns a function that rotates a coordinate by given angle in radians.

tf-rotate-90-degrees clj

(tf-rotate-90-degrees)

Returns a function that rotates a coordinate by 90 degrees.

tf-scale clj

(tf-scale & ns)

Returns a function that scales a coordinate by given amounts.

For example, ((tf-scale 10 2) [3 2]) = [30 4].

tf-shear clj

(tf-shear a b)

Returns a function that shears a coordinate by given factors.

See https://en.wikipedia.org/wiki/Shear_mapping.

For example, ((tf-shear 2 3) [10 5]) = [10 + 2 * 5, 5 + 3 * 10] = [20 35].

tf-translate clj

(tf-translate & deltas)

Returns a function that translates a coordinate by given deltas.

For example, ((tf-translate 10 20) [1 2]) = [11 22].

tf-transpose clj

(tf-transpose)

Returns a function that transposes a coordinate.

Returns a function just to keep it consistent with other tf-* functions.

For example, ((tf-transpose) [1 2]) = [2 1].

tf-vflip clj

(tf-vflip)

Returns a function that vertically flips a coordinate.

Returns a function just to keep it consistent with other tf-* functions.

For example, ((tf-vflip) [1 2]) = [1 -2].

transform clj

(transform g f)

(transform g f dimension)

Transforms a grid into another grid using given transformation function.

A transformation function accepts a key (coordinate vector) and returns another key.

For example transformation functions, take a look at the tf-* functions.

tree clj

(tree node)

(tree node text-wrapper-fn)

(tree node x-padding y-padding)

(tree node x-padding y-padding text-wrapper-fn)

(tree node x-padding y-padding text-wrapper-fn branch-marker)

Constructs a tree representation of a sequence.

An element of the sequence can be another sequence or a grid or anything that can be converted to a string.

For example, (tree [1 2 [3 [4 5] [6 7] 8]]) is ┌───┐ │ 1 │ └───┘ │ ┌───┐ │ 2 │ └───┘ │ ┌───┐ ┌───┐ ┌───┐ ┌───┐ │ 3 │ │ 4 │ │ 6 │ │ 8 │ └───┘ └───┘ └───┘ └───┘ │ │ ┌───┐ ┌───┐ │ 5 │ │ 7 │ └───┘ └───┘

update-ranges clj

(update-ranges metadata & ks)

valign clj

(valign grids)

(valign grids y-padding)

(valign grids y-padding center?)

Constructs a grid containing given grids aligned vertically.

For example, (valign [(text "A") (text "B") (text "C")]) is A B C

vfill clj

(vfill n)

(vfill n c)

Constructs a vertical-filler of given size.

For example, (vfill 3 *) is * * *

vline clj

(vline n)

(vline n body-char)

(vline n body-char start-char end-char)

Constructs a vertical line of given length.

For example, (vline 3) is | | |

vspacer clj

(vspacer n)

Constructs a vertical space of given length.

For example, (vspacer 5) is (space) (space) (space) (space) (space)

width clj

(width x)

|| clj

(|| y-padding & grids)

Vertically aligns given grids with some defaults.

Just a convenience wrapper for valign to accept grids as args and use some default values for padding and centering.