tessella 0.3.0

data/lib/tessella/kinds/pie.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Tessella
+    # A pie, or with donut: true a ring (DESIGN.md, "Chart and kinds"):
+    # labels and values as slices clockwise from the top, drawn on
+    # character cells twice as wide as tall, so the disc reads round in
+    # a terminal. Slices are told apart by fill -- █ ▓ ▒ ░ ╳ ╱ ╲ ∴ ● ○ ■
+    # ·, one width class, or # = + @ * : . o % & ~ x in ASCII, so at
+    # most 12 slices -- and, under color: true, by colour. The legend
+    # right of the disc gives each slice's share, or under it, wrapped
+    # to 40 columns or the disc's width, when the slices outnumber the
+    # rows. height: (12 by default) sets the size, so width: is
+    # refused. Values must be 0 or more, and not all 0. rim: :smooth
+    # draws the edge to the shape (PieRim).
+    class Pie < Chart
+        include PieRim
+
+        OPTIONS = (Chart::OPTIONS - %i[width xlim ylim canvas xscale] +
+                   %i[donut rim]).freeze
+        HOLE = 0.5
+        LEGEND = 40
+
+        def add(labels, values)
+            @labels = Array(labels).map(&:to_s)
+            @values = Check.finite!(Array(values), "value")
+            Check.same_size!(@labels, @values, %w[labels values])
+            values!
+            self
+        end
+
+        private
+
+        def values!
+            unless @values.all? { it >= 0 } && @values.sum.positive?
+                raise ValueError, "pie values must be 0 or more, not all 0"
+            end
+            Legend.fills!(@values.size, "slices")
+        end
+
+        def default_border = :none
+        def height = @opts.fetch(:height, 12)
+        def fill(i) = (@ascii ? Legend::ASCII_FILLS : Legend::FILLS)[i]
+        def slice_color(i) = Color::NAMES[i % Color::NAMES.size]
+
+        # Where each slice ends, as a share of the turn.
+        def ends
+            total = @values.sum.to_f
+            @values.each_index.map { @values[0..it].sum / total }
+        end
+
+        def body
+            w = height * 2
+            stops = ends
+            (0...height).map do |y|
+                (0...w).map { |x| disc_cell(x, y, w, stops) }
+            end
+        end
+
+        def disc_cell(x, y, w, stops)
+            dx = offset(x, w)
+            dy = offset(y, height)
+            i = slice_at(turn(dx, dy), stops)
+            cell = rim? ? rim_cell(x, y, w, i) : whole_cell(dx, dy)
+            cell || Cell.new(char: fill(i), color: slice_color(i))
+        end
+
+        # A cell in or out by its centre: blank, or nil for its fill.
+        def whole_cell(dx, dy)
+            r = Math.hypot(dx, dy)
+            Cell.blank if r > 1 || (@opts[:donut] && r < HOLE)
+        end
+
+        # A cell's centre from the disc's, in radii.
+        def offset(cell, cells) = (cell + 0.5 - (cells / 2.0)) / (cells / 2.0)
+
+        # 0 at the top, clockwise, as a share of the turn.
+        def turn(dx, dy) = (Math.atan2(dx, -dy) / (2 * Math::PI)) % 1.0
+
+        def slice_at(share, stops)
+            stops.index { share < it } || (stops.size - 1)
+        end
+
+        def frame
+            Frame.new(body: body, border: @border, ascii: @ascii,
+                      color: @color_on, title: @opts[:title],
+                      xlabel: @opts[:xlabel], ylabel: @opts[:ylabel],
+                      **legend)
+        end
+
+        # The legend beside the disc, centred, or under it, wrapped,
+        # when there are more slices than rows.
+        def legend
+            rows = legend_entries
+            return { under: Legend.wrap(rows, [height * 2, LEGEND].max) } if
+                rows.size > height
+
+            first = (height - rows.size) / 2
+            { right: rows.each_with_index.to_h { |text, i| [first + i, text] } }
+        end
+
+        def legend_entries
+            percents = shares
+            @labels.each_with_index.map do |label, i|
+                "#{fill(i)} #{label} #{percents[i]} %"
+            end
+        end
+
+        # Whole percents summing to 100: floors, the rest handed out by
+        # largest remainder.
+        def shares
+            exact = @values.map { it * 100.0 / @values.sum }
+            whole = exact.map(&:floor)
+            order = exact.each_index.sort_by { whole[it] - exact[it] }
+            order.first(100 - whole.sum).each { whole[it] += 1 }
+            whole
+        end
+    end
+
+    # (labels, values, donut: false, **opts): a new Pie.
+    def self.pie(labels, values, **)
+        Pie.new(**).add(labels, values)
+    end
+end

data/lib/tessella/kinds/pie_rim.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Tessella
+    # A pie's edge drawn to the shape (rim: :smooth or :basic): a cell
+    # the disc (or a donut's hole) only partly covers takes the glyph
+    # whose shape best fits that coverage, sampled as 4x8 -- ◢ ◣ ◤ ◥,
+    # halves, quadrants, quarter and eighth blocks, Image's petscii
+    # shapes -- in its slice's colour. The glyph is solid ink, so
+    # without colour the rim reads as an outline rather than as its
+    # slice's fill. :smooth adds Legacy Computing's 🮊 🮂 🮅, which
+    # older fonts lack; :basic keeps to Block Elements and Geometric
+    # Shapes. rim: :cells, the default, fills whole cells.
+    module PieRim
+        RIMS = %i[cells smooth basic].freeze
+        BASIC = %w[█ ▀ ▄ ▌ ▐ ▘ ▝ ▖ ▗ ▚ ▞ ▙ ▛ ▜ ▟ ▏ ▕ ▔ ▁ ▊ ▂ ▆
+                   ◢ ◣ ◤ ◥].freeze
+        LEGACY = %W[\u{1FB8A} \u{1FB82} \u{1FB85}].freeze
+
+        def initialize(**opts)
+            super
+            rim!
+        end
+
+        private
+
+        def rim = Borders.name(@opts.fetch(:rim, :cells))
+        def rim? = rim != :cells
+
+        def rim!
+            unless RIMS.include?(rim)
+                raise ArgumentError, "rim must be one of #{RIMS.join(", ")}: " \
+                                     "#{@opts[:rim].inspect}"
+            end
+            raise ArgumentError, "rim: #{rim} needs Unicode" if rim? && @ascii
+        end
+
+        # The cell as the rim draws it: blank, a shape, or nil when the
+        # disc covers it whole (its slice's fill then).
+        def rim_cell(x, y, w, slice)
+            cover = coverage(x, y, w)
+            return Cell.blank if cover.sum.zero?
+            return nil if cover.sum == cover.size
+
+            Cell.new(char: rim_glyph(cover), color: slice_color(slice))
+        end
+
+        def rim_glyph(cover)
+            rim_shapes.min_by do |_, ink|
+                ink.each_with_index.sum { |v, k| (v - cover[k])**2 }
+            end.first
+        end
+
+        def rim_shapes
+            @rim_shapes ||= Image::PETSCII.slice(
+                *BASIC, *(rim == :smooth ? LEGACY : [])
+            )
+        end
+
+        # 1.0 or 0.0 for each of the cell's 4x8 samples, row by row.
+        def coverage(x, y, w)
+            sw, sh = Image::PETSCII_SUB
+            (0...sh).flat_map do |sy|
+                (0...sw).map do |sx|
+                    disc_ink(sample(x, sx, sw, w), sample(y, sy, sh, height))
+                end
+            end
+        end
+
+        def sample(cell, sub, subs, cells)
+            ((cell + ((sub + 0.5) / subs)) - (cells / 2.0)) / (cells / 2.0)
+        end
+
+        def disc_ink(dx, dy)
+            r = Math.hypot(dx, dy)
+            r <= 1 && !(@opts[:donut] && r < Pie::HOLE) ? 1.0 : 0.0
+        end
+    end
+end

data/lib/tessella/kinds/sideways.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Tessella
+    # orientation: for the plotted kinds (line, scatter, stairs,
+    # density): :vertical, the default, puts values up the vertical
+    # axis; :horizontal swaps the axes, values along the horizontal one
+    # and x running up. Each series is stored swapped, so everything
+    # drawing it works unchanged; xlim:, ylim:, xlabel: and ylabel:
+    # keep their meaning and follow their axis. A kind with a floor at
+    # zero (an area) names it with zero_floor?, and the value axis
+    # takes in 0 whichever way it runs.
+    module Sideways
+        ORIENTATIONS = %i[vertical horizontal].freeze
+
+        def initialize(**opts)
+            super
+            orientation = opts.fetch(:orientation, :vertical)
+            unless ORIENTATIONS.include?(orientation)
+                raise ArgumentError,
+                      "unknown orientation: #{orientation.inspect}"
+            end
+            @sideways = orientation == :horizontal
+        end
+
+        def add(*, **)
+            super
+            return self unless @sideways
+
+            last = @series.pop
+            @series << last.with(x: last.y, y: last.x)
+            self
+        end
+
+        private
+
+        def zero_floor? = false
+
+        def xlim = Axis.limits(axis_values(:x), @opts[limit_key(:x)])
+        def ylim = Axis.limits(axis_values(:y), @opts[limit_key(:y)])
+
+        # The option limiting a canvas axis: its own, or the other's
+        # when the axes are swapped.
+        def limit_key(axis)
+            return :"#{axis}lim" unless @sideways
+
+            axis == :x ? :ylim : :xlim
+        end
+
+        def axis_values(axis)
+            values = @series.flat_map(&axis)
+            value_axis = @sideways ? :x : :y
+            zero_floor? && axis == value_axis ? [0, *values] : values
+        end
+
+        def frame_options(*)
+            options = super
+            return options unless @sideways
+
+            options.merge(xlabel: @opts[:ylabel], ylabel: @opts[:xlabel])
+        end
+    end
+end

data/lib/tessella/kinds/stem.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Tessella
+    # Stem-and-leaf plot (DESIGN.md, "Chart and kinds"): one sample, or
+    # two back to back, laid out as unicode_plot's stemplot does --
+    # stems beside a divider, leaves beside that, a key line below.
+    # Text laid out by its own rules, not a pixel canvas: Chart lends
+    # option checking and ascii/colour handling only; its canvas,
+    # frame and draw_series go unused.
+    class Stem < Chart
+        DEFAULT_SCALE = 10
+        MAX_STEMS = 1000
+        DIVIDER = "|"
+
+        def initialize(values, other = nil, scale: nil, **)
+            super(**)
+            @scale = Check.positive!(scale || DEFAULT_SCALE, "scale")
+            @left = leaves_by_stem(values)
+            @right = other && leaves_by_stem(other)
+            check_stem_count!([@left, @right].compact.flat_map(&:keys).uniq)
+            @left_color = @color_on ? auto_color : nil
+            @right_color = @color_on && @right ? auto_color : nil
+        end
+
+        def to_s
+            body = @right ? back_to_back_lines : single_lines
+            "#{(body + key_lines).map(&:rstrip).join("\n")}\n"
+        end
+
+        private
+
+        def numeric!(value, what)
+            return value if value.is_a?(Numeric)
+
+            raise ArgumentError, "non-numeric #{what}: #{value.inspect}"
+        end
+
+        def leaves_by_stem(values)
+            Check.finite!(Array(values), "value").each_with_object({}) do |v, h|
+                stem, leaf = stem_and_leaf(v)
+                (h[stem] ||= []) << leaf
+            end
+        end
+
+        def stem_and_leaf(value)
+            value = numeric!(value, "value")
+            # Rounded first: 0.3 / 0.1 is 2.9999999999999996, and
+            # truncating that would file 0.3 under leaf 2.
+            scaled = value.to_f.fdiv(@scale / 10.0).round(9)
+            whole = (scaled / 10).to_i
+            frac = (scaled - (whole * 10)).to_i
+            sign = value.negative? ? "-" : ""
+            ["#{sign}#{whole.abs}", frac.abs.to_s]
+        end
+
+        def stems_for(*hashes)
+            keys = hashes.compact.flat_map(&:keys).uniq
+            neg, pos = keys.partition { it.start_with?("-") }
+            negative_range(neg) + positive_range(pos)
+        end
+
+        # One line per stem from the lowest to the highest, empty ones
+        # included: past MAX_STEMS that is a wall of text, not a chart.
+        def check_stem_count!(keys)
+            return if keys.empty?
+
+            lo, hi = keys.map { it.start_with?("-") ? -it.to_i.abs : it.to_i }
+                         .minmax
+            count = hi - lo + 1 + (keys.any? { it.start_with?("-") } ? 1 : 0)
+            return if count <= MAX_STEMS
+
+            raise ArgumentError, "#{count} stems at scale " \
+                                 "#{Axis.label(@scale)}: raise the scale"
+        end
+
+        def negative_range(keys)
+            return [] if keys.empty?
+
+            lo, hi = keys.map { it.to_i.abs }.minmax
+            (lo..hi).to_a.reverse.map { "-#{it}" }
+        end
+
+        def positive_range(keys)
+            return [] if keys.empty?
+
+            lo, hi = keys.map(&:to_i).minmax
+            (lo..hi).to_a.map(&:to_s)
+        end
+
+        def single_lines
+            stems = stems_for(@left)
+            width = stems.map(&:length).max || 0
+            stems.map { single_line(it, width) }
+        end
+
+        def single_line(stem, width)
+            leaves = Color.wrap((@left[stem] || []).sort.join, @left_color)
+            "#{stem.rjust(width)} #{DIVIDER} #{leaves}"
+        end
+
+        def back_to_back_lines
+            stems = stems_for(@left, @right)
+            width = stems.map(&:length).max || 0
+            left_width = @left.values.map(&:length).max || 0
+            stems.map { back_to_back_line(it, width, left_width) }
+        end
+
+        def back_to_back_line(stem, width, left_width)
+            left = Color.wrap(left_leaves(stem, left_width), @left_color)
+            right = Color.wrap((@right[stem] || []).sort.join, @right_color)
+            mid = stem.rjust(width + 1).ljust(width + 2)
+            "#{left} #{DIVIDER}#{mid}#{DIVIDER} #{right}"
+        end
+
+        def left_leaves(stem, width)
+            (@left[stem] || []).sort.join.reverse.rjust(width)
+        end
+
+        def key_lines = [key_line, decimal_line]
+        def key_line = "Key: 1#{DIVIDER}0 = #{Axis.label(@scale)}"
+
+        def decimal_line
+            tens = Math.log10(@scale).truncate
+            side = tens.negative? ? "left" : "right"
+            "The decimal is #{tens.abs} digit(s) to the #{side} of #{DIVIDER}"
+        end
+    end
+
+    # (values, other = nil, scale: nil, **opts): a stem-and-leaf plot,
+    # or -- given other -- one back to back with it.
+    def self.stem(*, **)
+        Stem.new(*, **)
+    end
+end

data/lib/tessella/kinds/threshold.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Tessella
+    # A threshold for the plotted kinds (DESIGN.md, "Chart and kinds"):
+    # threshold: N draws a dashed reference line at N across the plot
+    # -- down it, sideways -- visible without colour; under color:
+    # true the cells beyond it take above: (red by default) and the
+    # rest below: (the series' own colour unless given), as asciigraph
+    # colours above and below a limit. The value axis takes N in.
+    module Threshold
+        def initialize(**opts)
+            super
+            limit = opts[:threshold]
+            return if limit.nil?
+
+            Check.finite!([limit], "threshold")
+            %i[above below].each do |key|
+                next unless opts.key?(key)
+                next if Color.valid?(opts[key])
+
+                raise ArgumentError, "unknown colour: #{opts[key].inspect}"
+            end
+        end
+
+        private
+
+        def threshold = @opts[:threshold]
+
+        def build_canvas(xl, yl)
+            canvas = super
+            threshold_line(canvas, xl, yl) if threshold
+            canvas
+        end
+
+        # A dot a two pixels along the line, so it reads as a rule.
+        def threshold_line(canvas, xl, yl)
+            if @sideways
+                canvas.dashed(threshold, yl.first, threshold, yl.last)
+            else
+                canvas.dashed(xl.first, threshold, xl.last, threshold)
+            end
+        end
+
+        def draw_or_mark(canvas, series)
+            return super unless threshold
+
+            super(canvas, series.with(color: split_color(series.color, canvas)))
+        end
+
+        # The colour of a cell: above: beyond the threshold, below:
+        # (or the series' colour) before it.
+        def split_color(own, canvas)
+            above = @opts.fetch(:above, :red)
+            below = @opts.fetch(:below, own)
+            lambda do |row, col|
+                beyond?(canvas, row, col) ? above : below
+            end
+        end
+
+        def beyond?(canvas, row, col)
+            return canvas.cell_column_value(col) > threshold if @sideways
+
+            canvas.cell_row_value(row) > threshold
+        end
+
+        def axis_values(axis)
+            values = super
+            return values unless threshold && axis == (@sideways ? :x : :y)
+
+            values + [threshold]
+        end
+    end
+end

data/lib/tessella/legend.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Tessella
+    # What tells series apart where colour may be off -- a fill each,
+    # one width class, so at most 12 series (pie slices, bar series) --
+    # and a legend set under a frame: its entries two blanks apart,
+    # wrapped into lines no wider than the frame's body, or than the
+    # widest entry, which is never split.
+    module Legend
+        FILLS = %w[█ ▓ ▒ ░ ╳ ╱ ╲ ∴ ● ○ ■ ·].freeze
+        ASCII_FILLS = %w[# = + @ * : . o % & ~ x].freeze
+
+        def self.fills!(count, what)
+            return if count <= FILLS.size
+
+            raise ArgumentError, "at most #{FILLS.size} #{what}, one a fill"
+        end
+
+        def self.wrap(entries, width)
+            limit = [width, *entries.map { Width.of(it) }].max
+            entries.each_with_object([]) do |entry, lines|
+                last = lines.last
+                if last && Width.of(last) + 2 + Width.of(entry) <= limit
+                    last << "  " << entry
+                else
+                    lines << +entry
+                end
+            end.join("\n")
+        end
+    end
+end

data/lib/tessella/lint/alphabet.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Tessella
+    module Lint
+        # What a text is made of (Tessella.alphabet), so the character
+        # policy is decided by measurement before a figure is drawn:
+        # "ascii", or "utf-8" and each glyph class present with its
+        # count, box-drawing first, and up to five unclassified glyphs
+        # by code point. Invalid bytes are a class of their own, not
+        # scrubbed away: a Latin-1 file is not ASCII either.
+        module Alphabet
+            CLASSES = {
+                "box-drawing" => 0x2500..0x257F,
+                "blocks" => 0x2580..0x259F,
+                "geometric" => 0x25A0..0x25FF,
+                "arrows" => 0x2190..0x21FF,
+                "braille" => 0x2800..0x28FF
+            }.freeze
+
+            def self.of(text)
+                seen = Hash.new(0)
+                other = {}
+                text.each_char { tally(it, seen, other) }
+                return "ascii" if seen.empty? && other.empty?
+
+                "utf-8 #{parts(seen, other).join(" ")}"
+            end
+
+            def self.tally(ch, seen, other)
+                return seen["invalid-utf-8"] += 1 unless ch.valid_encoding?
+                return if ch.ord <= 0x7F
+
+                name = classify(ch.ord)
+                name ? seen[name] += 1 : other[ch.ord] = ch
+            end
+
+            def self.classify(code)
+                CLASSES.each { |name, range| return name if range.cover?(code) }
+                return "wide" if Lint.wide?(code)
+                return "invisible" if Lint.invisible?(code)
+
+                "emoji-risk" if Lint.emoji_risk?(code)
+            end
+
+            def self.parts(seen, other)
+                parts = seen.map { |name, n| "#{name}(#{n})" }
+                return parts if other.empty?
+
+                sample = other.first(5).map do |code, ch|
+                    format("U+%<code>04X %<ch>s", code: code, ch: ch)
+                end
+                parts << "other(#{other.size}: #{sample.join(", ")})"
+            end
+        end
+    end
+end

data/lib/tessella/lint/drift.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Tessella
+    module Lint
+        # A vertical anchor (a lifeline, a box edge) one column off on a
+        # row or two. Per figure, the rows carrying a vertical at each
+        # display column are counted: a column used by few rows, beside
+        # one used by many, with no row using both, is a drifted anchor
+        # rather than a second one. Boxes of different widths share no
+        # such neighbour, and a double line (││) has rows using both.
+        module Drift
+            MIN_ROWS = 4
+            RATIO = 3
+
+            # A Markdown pipe table's separator row: such a paragraph is
+            # not a figure, its pipes need not line up in the source.
+            MD_TABLE_SEP = /\A\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*\z/
+
+            private
+
+            def check_anchor_drift(sec)
+                group = []
+                sec.lines.each_with_index do |line, i|
+                    if line.strip.empty?
+                        flag_anchor_drift(sec, group)
+                        group = []
+                    else
+                        group << [i, line]
+                    end
+                end
+                flag_anchor_drift(sec, group)
+            end
+
+            def flag_anchor_drift(sec, group)
+                return unless drift_figure?(group)
+
+                rows = vertical_rows(group)
+                return if rows.length < MIN_ROWS
+
+                count = rows.flat_map(&:last).tally
+                count.default = 0
+                count.keys.sort.each do |c|
+                    anchor = drift_anchor(rows, count, c)
+                    report_drift(sec, rows, count, [c, anchor]) if anchor
+                end
+            end
+
+            # [index, its distinct vertical columns] per row that has any.
+            def vertical_rows(group)
+                group.map { |i, line| [i, vertical_columns(line).uniq] }
+                     .reject { |_, cols| cols.empty? }
+            end
+
+            def drift_figure?(group)
+                group.any? do |_, line|
+                    bare = line.gsub(INLINE_CODE, "")
+                    bare.match?(BOX_CHAR) || Mixing.ascii_structural?(bare)
+                end && group.none? { |_, line| line.match?(MD_TABLE_SEP) }
+            end
+
+            def drift_anchor(rows, count, col)
+                [col - 1, col + 1].find do |d|
+                    count[d] >= MIN_ROWS && count[d] >= RATIO * count[col] &&
+                        rows.none? do |_, cols|
+                            cols.include?(col) && cols.include?(d)
+                        end
+                end
+            end
+
+            def report_drift(sec, rows, count, pair)
+                col, anchor = pair
+                bad = rows.select { |_, cols| cols.include?(col) }
+                          .map { |i, _| sec.first + i }
+                report(sec, bad.first - sec.first,
+                       "vertical at column #{col} on #{bad.length} row(s) " \
+                       "(#{bad.join(",")}) beside the figure's anchor at " \
+                       "column #{anchor} (#{count[anchor]} rows) -- one " \
+                       "column off?")
+            end
+        end
+    end
+end

data/lib/tessella/lint/fences.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Tessella
+    module Lint
+        # fences: true -- each fenced block of a Markdown text linted on
+        # its own, with the text's line numbers, since a whole document
+        # would read its prose and tables as art. A fence opens with
+        # three or more backticks or tildes (indented at most three
+        # spaces) and closes with a run of the same glyph at least as
+        # long; an unclosed fence runs to the end. An allow-mixed
+        # marker on the last non-blank line before a fence exempts
+        # that block from the mixing check.
+        module Fences
+            OPEN = /\A {0,3}(`{3,}|~{3,})/
+
+            def self.sections(lines)
+                out = []
+                i = 0
+                while i < lines.length
+                    fence = lines[i][OPEN, 1]
+                    i += 1
+                    next unless fence
+
+                    out << section(lines, i, closing(lines, i, fence))
+                    i = out.last.first + out.last.lines.length
+                end
+                out
+            end
+
+            # The index of the closing fence, or lines.length.
+            def self.closing(lines, from, fence)
+                glyph = Regexp.escape(fence[0])
+                close = /\A {0,3}#{glyph}{#{fence.length},}\s*\z/
+                (from...lines.length).find { lines[it].match?(close) } ||
+                    lines.length
+            end
+
+            def self.section(lines, from, stop)
+                Section.new(lines: lines[from...stop], first: from + 1,
+                            exempt: marked?(lines, from - 1))
+            end
+
+            def self.marked?(lines, fence_at)
+                before = lines[0...fence_at].reverse.find do |line|
+                    !line.strip.empty?
+                end
+                before&.match?(MIXED_MARKER) || false
+            end
+        end
+    end
+end