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

++ 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.

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 \+}})

Constructs a grid wrapping given grid 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 g & escape-codes)

Decorates a grid with given ansi-escape-codes.

down-arrow clj

(down-arrow n)

(down-arrow n body-char)

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

Constructs a down-arrow of given length.

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

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 y-padding)

(halign grids x-padding y-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 " ".

left-arrow clj

(left-arrow n)

(left-arrow n body-char)

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

Constructs a left-arrow of given length.

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

left-right-arrow clj

(left-right-arrow n)

(left-right-arrow n body-char)

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

Constructs a left-right-arrow of given length.

For example, (left-right-arrow 4) 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 │ ╰ ╯

render clj multimethod

render-grid clj multimethod

right-arrow clj

(right-arrow n)

(right-arrow n body-char)

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

Constructs a right-arrow of given length.

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

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?]
        :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 | +----+----+

table0 clj

(table0 ks rows)

(table0 ks rows header?)

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

table1 clj

(table1 ks rows)

(table1 ks rows header?)

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 │ └────┴────┘

table2 clj

(table2 ks rows)

(table2 ks rows header?)

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 │ ╰────┴────╯

table3 clj

(table3 ks rows)

(table3 ks rows header?)

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 : :....:....:

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)

tf-project clj

(tf-project target-dimension)

(tf-project target-dimension project-fn)

tf-rotate clj

(tf-rotate radians)

tf-rotate-90-degrees clj

(tf-rotate-90-degrees)

tf-scale clj

(tf-scale & ns)

tf-translate clj

(tf-translate & deltas)

tf-transpose clj

(tf-transpose)

tf-vflip clj

(tf-vflip)

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 │ └───┘ └───┘

up-arrow clj

(up-arrow n)

(up-arrow n body-char)

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

Constructs a up-arrow of given length.

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

up-down-arrow clj

(up-down-arrow n)

(up-down-arrow n body-char)

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

Constructs a up-down-arrow of given length.

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

update-ranges clj

(update-ranges metadata & ks)

valign clj

(valign grids)

(valign grids x-padding y-padding)

(valign grids x-padding 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.