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

++ 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]
      :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 opts})

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

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

box1 clj

(box1 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]
       :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 "┌"}})

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
              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]
       :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 "╒"}})

Constructs a grid wrapping given grid into a box.

Similar to box, but uses different border.

For example, (box2 (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]
           :or {point-symbol \* draw-axis true x-label "x" y-label "y"}})

Constructs a xy-chart (scatter plot).

For example, (chart-xy (range) [0 1 2 1 0 1 2 1 0]) 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 │ ╰ ╯

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 header? row-decorations]
        :or {ns-char \|
             ews-char \+
             nse-char \+
             ew-char \-
             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])

table0 clj

(table0 ks rows)

(table0 ks rows header?)

(table0 ks rows header? 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? 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? 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? 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 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.