tessella 0.3.0

data/lib/tessella/axis.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Tessella
+    # Axis extremes and number labels for a chart's scale (DESIGN.md).
+    module Axis
+        INT64_RANGE =
+            (-9_223_372_036_854_775_808..9_223_372_036_854_775_807)
+
+        # lim [a, b] given and not [0, 0]: returned as is; otherwise the
+        # data's extent widened to round values exactly as unicode_plot
+        # widens it (its axis labels are the oracle).
+        def self.limits(values, lim = nil)
+            lim ||= [0, 0]
+            auto = lim == [0, 0]
+            mi, ma = (auto ? values : lim).minmax.map(&:to_f)
+            mi, ma = widen(mi) if mi == ma
+            auto ? narrow(mi, ma) : [mi, ma]
+        end
+
+        # Integer as is; Float in the shortest round-tripping form, no
+        # exponent for |x| in 1e-4...1e15 (Ruby's own Float#to_s already
+        # holds to that range, and keeps a Float's digits where an
+        # Integer input has none).
+        def self.label(number) = number.to_s
+
+        # An axis extreme: limits are Floats, and a whole one prints
+        # without its ".0" (10, not 10.0), as unicode_plot prints them;
+        # any other value as label does. For value labels, use label.
+        def self.tick(number)
+            number = number.to_i if number.is_a?(Float) && roundable?(number)
+            label(number)
+        end
+
+        # +-1, as unicode_plot widens a constant; from about 1e16 up a
+        # Float cannot hold mi +- 1, so the step grows by tens until it
+        # changes mi (unicode_plot crashes there instead).
+        def self.widen(mi)
+            d = 1.0
+            d *= 10 while mi + d == mi || mi - d == mi
+            [mi - d, mi + d]
+        end
+
+        def self.narrow(mi, ma)
+            diff = ma - mi
+            lo = round_subtick(mi, diff, :down)
+            hi = round_subtick(ma, diff, :up)
+            [lo.to_f, hi.to_f]
+        end
+
+        def self.round_subtick(x, m, dir)
+            return 0.0 if x.zero?
+
+            digits = neg_log10_digits(m)
+            up = dir == :up
+            if x.positive?
+                up ? x.ceil(digits) : x.floor(digits)
+            else
+                up ? -(-x).floor(digits) : -(-x).ceil(digits)
+            end
+        end
+
+        def self.neg_log10_digits(m)
+            v = -Math.log10(m)
+            roundable?(v) ? v.ceil + 1 : v.floor + 1
+        end
+
+        def self.roundable?(x)
+            x.finite? && INT64_RANGE.cover?(x) && x.to_i == x
+        end
+    end
+end

data/lib/tessella/bitfield.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Tessella
+    # Bitfield (ported byte for byte from the ascii-art skill's
+    # scripts/bitfield.rb): an RFC-style packet / bit-field diagram --
+    # a two-row bit ruler, "+-+" tick rows, and each field's name
+    # centred in its own cell. Pure ASCII always; RFC 2360's own
+    # convention, so there is no Unicode mode (no "ascii:" option).
+    #
+    # `fields` is either the script's "name:bits" text (# comments and
+    # blank lines skipped) or an Array of [name, bits] pairs. A field
+    # wider than the bits left in its row continues on the next
+    # row(s), the name repeated (or truncated under abbrev:) in each
+    # one, as RFC 791 draws its Options field.
+    module Bitfield
+        WORD_SIZES = [8, 16, 32, 64].freeze
+        FIELD_RE = /\A\s*([^:]+?)\s*:\s*(\d+)\s*\z/
+
+        Field = Struct.new(:name, :bits, :line)
+        RowState = Struct.new(:cursor, :row, :rows)
+
+        def self.block(fields, word:, octets:, ruler:, abbrev:)
+            word!(word)
+            rows = layout_rows(ascii_names!(fields_for(fields)), word, abbrev)
+            show_ruler = ruler && !octets
+            Block.new(render(rows, word, show_ruler, octets))
+        end
+
+        def self.word!(word)
+            return word if WORD_SIZES.include?(word)
+
+            raise ArgumentError, "word must be 8, 16, 32 or 64: " \
+                                 "#{word.inspect}"
+        end
+
+        # The script's own text format, or the fields already given.
+        # A bit-field is drawn in ASCII only, so its names must be.
+        def self.ascii_names!(fields)
+            fields.each_with_index do |f, i|
+                next if f.name.ascii_only?
+
+                where = f.line ? "line #{f.line}" : "field #{i + 1}"
+                raise ArgumentError, "#{where}: name #{f.name.inspect} is " \
+                                     "non-ASCII (a bit-field is ASCII)"
+            end
+        end
+
+        def self.fields_for(fields)
+            return parse(fields) if fields.is_a?(String)
+
+            fields.each_with_index.map { |(name, bits), i| pair(name, bits, i) }
+        end
+
+        def self.pair(name, bits, index)
+            unless bits.is_a?(Integer) && bits.positive?
+                raise ArgumentError, "field #{index + 1} (#{name.inspect}): " \
+                                     "bits must be a positive Integer: " \
+                                     "#{bits.inspect}"
+            end
+            Field.new(name.to_s, bits, nil)
+        end
+    end
+
+    # Parsing the "name:bits" text format: one field per line, "#"
+    # comments and blank lines skipped.
+    module Bitfield
+        def self.parse(text)
+            fields = text.each_line.with_index(1).filter_map do |raw, lineno|
+                line = raw.chomp
+                next if line.strip.empty? || line.lstrip.start_with?("#")
+
+                parse_line(line, lineno)
+            end
+            raise ArgumentError, "no fields given" if fields.empty?
+
+            fields
+        end
+
+        def self.parse_line(line, lineno)
+            m = FIELD_RE.match(line)
+            unless m
+                raise ArgumentError,
+                      "line #{lineno}: #{line.inspect} not name:bits"
+            end
+            Field.new(m[1], bits_for(m[2], line, lineno), lineno)
+        end
+
+        def self.bits_for(digits, line, lineno)
+            bits = digits.to_i
+            return bits unless bits.zero?
+
+            raise ArgumentError, "line #{lineno}: #{line.inspect} has 0 bits"
+        end
+    end
+
+    # Laying fields into rows of word: bits each, a field that outgrows
+    # its row continuing on the next (RowState tracks the row being
+    # filled, and the rows closed so far).
+    module Bitfield
+        # A name that already fits returns as-is; one too wide is bad
+        # input unless abbrev truncates it to width - 1 characters plus
+        # a dot.
+        def self.fit_label(name, width, abbrev)
+            return name if name.length <= width
+            unless abbrev
+                raise ArgumentError, "name #{name.inspect} needs " \
+                                     "#{name.length} columns, this cell " \
+                                     "only has #{width}"
+            end
+            "#{name[0, width - 1]}."
+        end
+
+        def self.close_row(state, word)
+            return unless state.cursor == word
+
+            state.rows << state.row
+            state.row = []
+            state.cursor = 0
+        end
+
+        def self.place_field(field, word, abbrev, state)
+            remaining = field.bits
+            until remaining.zero?
+                take = [remaining, word - state.cursor].min
+                label = fit_label(field.name, (2 * take) - 1, abbrev)
+                state.row << { bits: take, label: label }
+                state.cursor += take
+                remaining -= take
+                close_row(state, word)
+            end
+        end
+
+        def self.layout_rows(fields, word, abbrev)
+            state = RowState.new(0, [], [])
+            fields.each { place_field(it, word, abbrev, state) }
+            state.rows << state.row unless state.row.empty?
+            state.rows
+        end
+
+        def self.row_bits(row) = row.sum { it[:bits] }
+    end
+
+    # Rendering rows into text lines: the bit ruler, a tick line per
+    # row (and a closing one), and each row's content line.
+    module Bitfield
+        def self.tick_line(bits, step)
+            positions = (0..bits).step(step).to_a
+            positions << bits if positions.last != bits
+            line = +"+"
+            positions.each_cons(2) do |p0, p1|
+                line << ("-" * ((2 * (p1 - p0)) - 1)) << "+"
+            end
+            line
+        end
+
+        def self.ruler_lines(word)
+            tens = +""
+            units = +""
+            word.times do |i|
+                tens << " " << ((i % 10).zero? ? (i / 10).to_s : " ")
+                units << " " << (i % 10).to_s
+            end
+            [tens.rstrip, units.rstrip]
+        end
+
+        def self.content_line(segments)
+            line = +"|"
+            segments.each do |seg|
+                line << Width.center(seg[:label], (2 * seg[:bits]) - 1) << "|"
+            end
+            line
+        end
+
+        # A tick line between two rows spans the wider of them, so a
+        # short last row does not leave the row above it open.
+        def self.render(rows, word, show_ruler, octets)
+            step = octets ? 8 : 1
+            lines = show_ruler ? ruler_lines(word) : []
+            above = 0
+            rows.each do |row|
+                lines << tick_line([above, row_bits(row)].max, step)
+                lines << content_line(row)
+                above = row_bits(row)
+            end
+            lines << tick_line(above, step)
+        end
+    end
+
+    def self.bitfield(fields, word: 32, octets: false, ruler: true,
+                      abbrev: false)
+        Bitfield.block(fields, word: word, octets: octets, ruler: ruler,
+                               abbrev: abbrev)
+    end
+end

data/lib/tessella/block.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Tessella
+    # A finished figure as lines of text: what every module returns and
+    # what composition takes (DESIGN.md, "Blocks and composition"). A
+    # block is never rewritten, only padded on the right; its trailing
+    # blank lines are dropped, a tab is refused (its width is up to the
+    # viewer), and so is a block with no line left.
+    class Block
+        attr_reader :lines
+
+        # A Block, a String, or anything whose to_s is the figure (a
+        # chart): the composition functions take any of them.
+        def self.from(figure)
+            figure.is_a?(Block) ? figure : new(figure.to_s.lines(chomp: true))
+        end
+
+        def initialize(lines)
+            lines = lines.map(&:to_s)
+            lines.pop while lines.last&.strip&.empty?
+            raise ArgumentError, "empty block" if lines.empty?
+
+            check_tabs!(lines)
+            @lines = lines.freeze
+            freeze
+        end
+
+        def width = @lines.map { Width.of(it) }.max
+        def height = @lines.size
+
+        # Every line without its trailing blanks, each ended by "\n";
+        # under target :web, emoji-capable glyphs kept as text (Target).
+        def to_s = Target.adapt(@lines.map { "#{it.rstrip}\n" }.join)
+
+        def ascii? = @lines.all?(&:ascii_only?)
+
+        # The first line over max columns raises, naming its width.
+        def check_width!(max)
+            @lines.each_with_index do |line, i|
+                w = Width.of(line.rstrip)
+                next if w <= max
+
+                raise ArgumentError, "output is #{w} columns on line " \
+                                     "#{i + 1} (max-width #{max})"
+            end
+            self
+        end
+
+        private
+
+        def check_tabs!(lines)
+            i = lines.index { it.include?("\t") }
+            raise ArgumentError, "line #{i + 1}: tab character" if i
+        end
+    end
+end

data/lib/tessella/borders.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Tessella
+    # The border glyph sets every framed figure draws with (a frame, a
+    # table): corners, a horizontal and a vertical run. Under ascii:
+    # true the set is "ascii" from the first byte; asking for another
+    # one with it is refused rather than silently overridden.
+    #
+    # Besides the named sets, a custom one: a Set, or a String of six
+    # glyphs in Set order (tl tr bl br h v), or of eleven for a table,
+    # whose five more are its tees (top_t bot_t sep_l sep_t sep_r:
+    # down from the top edge, up from the bottom one, and the left
+    # tee, cross and right tee of a separator row). Each glyph is one
+    # visible column; under ascii: true each must be ASCII.
+    module Borders
+        Set = Data.define(:tl, :tr, :bl, :br, :h, :v)
+
+        STYLES = {
+            light: Set.new("┌", "┐", "└", "┘", "─", "│"),
+            heavy: Set.new("┏", "┓", "┗", "┛", "━", "┃"),
+            double: Set.new("╔", "╗", "╚", "╝", "═", "║"),
+            rounded: Set.new("╭", "╮", "╰", "╯", "─", "│"),
+            dashed: Set.new("┌", "┐", "└", "┘", "┄", "┆"),
+            dashed_fine: Set.new("┌", "┐", "└", "┘", "┈", "┊"),
+            heavy_dashed: Set.new("┏", "┓", "┗", "┛", "┅", "┇"),
+            heavy_dashed_fine: Set.new("┏", "┓", "┗", "┛", "┉", "┋"),
+            double_h: Set.new("╒", "╕", "╘", "╛", "═", "│"),
+            double_v: Set.new("╓", "╖", "╙", "╜", "─", "║"),
+            ascii: Set.new("+", "+", "+", "+", "-", "|")
+        }.freeze
+
+        TEE_KEYS = %i[top_t bot_t sep_l sep_t sep_r].freeze
+
+        def self.fetch(style, ascii: false)
+            return custom(style, ascii: ascii).first if custom?(style)
+
+            name = Borders.name(style || (ascii ? :ascii : :light))
+            if ascii && name != :ascii
+                raise ArgumentError, "style #{name} conflicts with ascii: true"
+            end
+
+            STYLES.fetch(name) do
+                raise ArgumentError, "unknown style: #{name.inspect}"
+            end
+        end
+
+        # A style's name as a Symbol: "double-h" and :double_h alike.
+        def self.name(style) = style.to_s.tr("-", "_").to_sym
+
+        # A Set, or a String that names no style: a glyph set.
+        def self.custom?(style)
+            style.is_a?(Set) ||
+                (style.is_a?(String) && !STYLES.key?(name(style)) &&
+                 !style.match?(/\A[a-z_-]+\z/))
+        end
+
+        # [Set, tees Hash or nil] for a custom style, checked.
+        def self.custom(style, ascii: false)
+            glyphs = style.is_a?(Set) ? style.to_h.values : style.chars
+            unless [6, 11].include?(glyphs.size)
+                raise ArgumentError, "a border set is 6 glyphs (tl tr bl br " \
+                                     "h v), or 11 with a table's tees: " \
+                                     "#{style.inspect}"
+            end
+            glyphs.each { check_glyph!(it, ascii) }
+            [Set.new(*glyphs.first(6)), tees(glyphs)]
+        end
+
+        def self.tees(glyphs)
+            glyphs.size == 11 ? TEE_KEYS.zip(glyphs.last(5)).to_h : nil
+        end
+
+        def self.check_glyph!(glyph, ascii)
+            unless glyph.is_a?(String) && glyph.length == 1 &&
+                   Width.of(glyph) == 1 && glyph.match?(/\A[[:graph:]]\z/)
+                raise ArgumentError, "a border glyph is one visible " \
+                                     "column: #{glyph.inspect}"
+            end
+            return unless ascii && !glyph.ascii_only?
+
+            raise ArgumentError, "border glyph #{glyph} conflicts with " \
+                                 "ascii: true"
+        end
+    end
+end

data/lib/tessella/canvas/area.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Tessella
+    class Canvas
+        # An area under a curve (a line chart's area: true), as btop
+        # draws its graphs: every pixel column the series spans is set
+        # from the canvas floor up to the curve, so a braille cell holds
+        # two independent bars of 0..4 dots and a block cell two of
+        # 0..2. A column's height is the curve's value at its centre,
+        # or the highest point falling inside it, so a peak narrower
+        # than a column is not lost.
+        module Area
+            # color: one colour name for every cell, or a callable
+            # taking a cell row (0 at the top) and returning one.
+            # across: true fills each pixel row instead, from the left
+            # edge out to the curve (x the value, y the position), the
+            # callable then taking a cell column.
+            def area(xs, ys, color: nil, across: false)
+                return area_across(xs, ys, color) if across
+
+                (0...pixel_width).each do |px|
+                    value = column_value(xs, ys, px)
+                    fill_column(px, column_top(value), color) if value
+                end
+            end
+
+            # The value at the middle of a cell row (0 the top) or column.
+            def cell_row_value(row)
+                @yhi - ((row + 0.5) * (@yhi - @ylo) / height)
+            end
+
+            def cell_column_value(col)
+                @xlo + ((col + 0.5) * (@xhi - @xlo) / width)
+            end
+
+            # A dashed line in data coordinates: every other pixel set.
+            def dashed(x0, y0, x1, y1, color: nil)
+                from = to_pixel(x0, y0).map(&:floor)
+                to = to_pixel(x1, y1).map(&:floor)
+                steps = from.zip(to).map { |a, b| (b - a).abs }.max
+                (0..steps).step(2) do |i|
+                    t = steps.zero? ? 0 : i.fdiv(steps)
+                    draw_pixel(*between(from, to, t), color)
+                end
+            end
+
+            # The pixel t (0..1) of the way from one pixel to another.
+            def between(from, to, t)
+                from.zip(to).map { |a, b| (a + ((b - a) * t)).round }
+            end
+
+            # A bar along pixel row py (0 the top), length pixels from
+            # the left edge: a horizontal bar chart's bar on a canvas.
+            def row_bar(py, length, color: nil)
+                length.clamp(0, pixel_width).times do |px|
+                    set_sub_pixel(px, py, color)
+                end
+            end
+
+            # A bar up pixel column px, height pixels from the floor: a
+            # column chart's column on a canvas.
+            def column_bar(px, height, color: nil)
+                ((pixel_height - height.clamp(0, pixel_height))...pixel_height)
+                    .each { set_sub_pixel(px, it, color) }
+            end
+
+            private
+
+            def area_across(xs, ys, color)
+                (0...pixel_height).each do |py|
+                    value = row_value(xs, ys, py)
+                    next unless value
+
+                    share = (value - @xlo).fdiv(@xhi - @xlo).clamp(0.0, 1.0)
+                    (share * pixel_width).round.times do |px|
+                        set_sub_pixel(px, py, shade_across(color, px, py))
+                    end
+                end
+            end
+
+            # The value at a pixel row: the curve at its centre (x as a
+            # function of y), or the highest x of a point inside it.
+            def row_value(xs, ys, py)
+                lo, hi = row_span(py)
+                inside = ys.each_index.select { ys[it] > lo && ys[it] <= hi }
+                [*inside.map { xs[it] }, curve_at(ys, xs, (lo + hi) / 2.0)]
+                    .compact.max
+            end
+
+            def row_span(py)
+                step = (@yhi - @ylo).fdiv(pixel_height)
+                hi = @yhi - (py * step)
+                [hi - step, hi]
+            end
+
+            # A callable of (row, col), as threshold: gives, or of the
+            # one coordinate a gradient runs along.
+            def shade_across(color, px, py)
+                return color unless color.respond_to?(:call)
+                return cell_color(color, px, py) if color.arity == 2
+
+                color.call(px / x_pixel_per_char)
+            end
+
+            def column_value(xs, ys, px)
+                lo, hi = column_span(px)
+                inside = xs.each_index.select { xs[it] >= lo && xs[it] < hi }
+                [*inside.map { ys[it] }, curve_at(xs, ys, (lo + hi) / 2.0)]
+                    .compact.max
+            end
+
+            def column_span(px)
+                step = (@xhi - @xlo).fdiv(pixel_width)
+                [@xlo + (px * step), @xlo + ((px + 1) * step)]
+            end
+
+            # The highest y any segment of the path takes at x, or nil
+            # where the path does not reach.
+            def curve_at(xs, ys, x)
+                (0...(xs.size - 1)).filter_map do |i|
+                    segment_at(xs[i], ys[i], xs[i + 1], ys[i + 1], x)
+                end.max
+            end
+
+            def segment_at(x0, y0, x1, y1, x)
+                return nil unless x.between?(*[x0, x1].minmax)
+                return [y0, y1].max if x0 == x1
+
+                y0 + ((y1 - y0) * (x - x0).fdiv(x1 - x0))
+            end
+
+            # The first pixel row filled: the column's height in pixels,
+            # rounded, counted down from the top.
+            def column_top(value)
+                share = (value - @ylo).fdiv(@yhi - @ylo).clamp(0.0, 1.0)
+                pixel_height - (share * pixel_height).round
+            end
+
+            def fill_column(px, top, color)
+                (top...pixel_height).each do |py|
+                    set_sub_pixel(px, py, shade(color, px, py))
+                end
+            end
+
+            def shade(color, px, py)
+                return color unless color.respond_to?(:call)
+                return cell_color(color, px, py) if color.arity == 2
+
+                color.call(py / y_pixel_per_char)
+            end
+        end
+
+        include Area
+    end
+end

data/lib/tessella/canvas/ascii.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Tessella
+    class Canvas
+        # 3x3 sub-pixels per cell, drawn with ASCII only. There is no
+        # Unicode or ASCII standard for "this 3x3 dot pattern means
+        # this character" the way there is for braille dots or block
+        # quadrants, so the glyph follows an original rule, by where
+        # the set sub-pixels lie (D2): one populated row reads as a
+        # mark along that row (top: ` left, ' centre or right, " for
+        # two or more; middle: -; bottom: . one, _ for two or more);
+        # a full middle row with pixels elsewhere is still - unless
+        # some column is also full, which (with a full row) is a
+        # crossing; a column two- or three-deep with nothing in the
+        # other columns is |; a dominant diagonal is / or \; a
+        # crossing (both diagonals, or a full row and a full column)
+        # is +; anything else falls back to whichever of - or | its
+        # coverage resembles more. # overrides all of the above once
+        # 7 or more of the 9 sub-pixels are set: by then a full row
+        # and a full column always coexist (pigeonhole: 3 rows summing
+        # to >= 7 force one to be full, and likewise for columns), so
+        # "dense" and "a crossing" are never really distinct cases --
+        # density is checked first and reads as solid ink, not a plus
+        # sign. bits index as sy * SIZE + sx (top row first).
+        class Ascii < Canvas
+            SIZE = 3
+
+            private
+
+            def x_pixel_per_char = SIZE
+            def y_pixel_per_char = SIZE
+
+            def encode(code, sub_x, sub_y)
+                code | (1 << ((sub_y * SIZE) + sub_x))
+            end
+
+            def decode(code)
+                return " " if code.zero?
+                glyph_for(code)
+            end
+
+            def glyph_for(code)
+                rows = row_counts(code)
+                cols = col_counts(code)
+                row_only_glyph(code, rows) ||
+                    full_middle_glyph(rows, cols) || column_glyph(cols) ||
+                    dense_glyph(code) ||
+                    diag_or_cross_glyph(code, rows, cols) ||
+                    fallback_glyph(rows, cols)
+            end
+
+            def dense_glyph(code)
+                "#" if (0...9).count { code[it] == 1 } >= 7
+            end
+
+            def row_counts(code)
+                (0..2).map { |r| (0..2).count { code[(r * SIZE) + it] == 1 } }
+            end
+
+            def col_counts(code)
+                (0..2).map { |c| (0..2).count { code[(it * SIZE) + c] == 1 } }
+            end
+
+            def only_row?(rows, idx)
+                others = (0..2).to_a - [idx]
+                rows[idx].positive? && others.all? { rows[it].zero? }
+            end
+
+            def row_only_glyph(code, rows)
+                return top_row_glyph(code) if only_row?(rows, 0)
+                return bottom_row_glyph(code) if only_row?(rows, 2)
+                "-" if only_row?(rows, 1)
+            end
+
+            def top_row_glyph(code)
+                set = (0..2).select { code[it] == 1 }
+                return "\"" if set.size >= 2
+                set.first.zero? ? "`" : "'"
+            end
+
+            def bottom_row_glyph(code)
+                (0..2).count { code[6 + it] == 1 } >= 2 ? "_" : "."
+            end
+
+            def full_middle_glyph(rows, cols)
+                return nil unless rows[1] == 3
+                "-" unless cols.any? { it == 3 }
+            end
+
+            def column_glyph(cols)
+                idx = (0..2).find { cols[it] >= 2 }
+                return nil unless idx
+                "|" if (0..2).all? { it == idx || cols[it].zero? }
+            end
+
+            def diagonal_counts(code)
+                [[6, 4, 2].count { code[it] == 1 },
+                 [0, 4, 8].count { code[it] == 1 }]
+            end
+
+            def crossing?(rising, falling, rows, cols)
+                (rising >= 2 && falling >= 2) ||
+                    (rows.any? { it == 3 } && cols.any? { it == 3 })
+            end
+
+            def diag_or_cross_glyph(code, rows, cols)
+                rising, falling = diagonal_counts(code)
+                return "+" if crossing?(rising, falling, rows, cols)
+                return "/" if rising >= 2 && rising > falling
+                "\\" if falling >= 2 && falling > rising
+            end
+
+            def fallback_glyph(rows, cols)
+                rows.max >= cols.max ? "-" : "|"
+            end
+        end
+
+        register(:ascii, Ascii)
+    end
+end