pp-grid.object — org.clojars.rorokimdim/pp-grid 0.1.5

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

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

fill clj

(fill w h)

(fill w h c)

Constructs a filler of given width and height.

For example, (fill 4 4 *) is

---

---

---

---

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

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

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.

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

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