etassia 0.1.0

data/lib/etassia/notation/plantuml_salt/layout.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require_relative "../../text_measurement"
+require_relative "box"
+require_relative "mark"
+require_relative "run"
+require_relative "scene"
+require_relative "grid_marks"
+require_relative "group_marks"
+require_relative "scroll_marks"
+require_relative "tab_marks"
+require_relative "tree_marks"
+require_relative "widget_marks"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # Measures a {Block} tree and places it. Rows are as tall as their
+      # tallest cell; every column is as wide as its widest cell. A tree
+      # row's first cell is pushed right by its depth.
+      class Layout
+        include TreeMarks
+        include GridMarks
+        include GroupMarks
+        include ScrollMarks
+        include TabMarks
+        include WidgetMarks
+
+        TREE_ROW_HEIGHT = TreeMarks::ROW_HEIGHT
+        TREE_PAD = TreeMarks::PAD
+        TREE_INDENT = TreeMarks::INDENT
+
+        MARGIN = 5.0
+        CANVAS = "#FFFFFF"
+
+        # @param block [Block] the parsed root
+        # @return [Scene]
+        def call(block, **)
+          @marks = []
+          @overlays = []
+          root = block.rows.size == 1 ? lone_block(block) : block
+          width, height = measure(root)
+          place(root, Box.new(MARGIN, MARGIN, width, height))
+          scene(width + (2 * MARGIN), height + (2 * MARGIN))
+        end
+
+        private
+
+        # The canvas: a white ground, the marks, then what hangs over the
+        # edge of the layout (an open droplist), which the canvas grows to
+        # hold.
+        def scene(width, height)
+          reach = @overlays.map(&:box)
+          width = [width, *reach.map(&:right)].max.ceil
+          height = [height, *reach.map(&:bottom)].max.ceil
+          ground = Mark.new(:rect, Box.new(0.0, 0.0, width, height),
+                            fill: CANVAS, ink: "none", weight: 0.0)
+          Scene.new(width: width, height: height,
+                    marks: [ground, *@marks, *@overlays])
+        end
+
+        def lone_block(block)
+          cells = block.rows.first.cells
+          cells.size == 1 && cells.first.is_a?(Block) ? cells.first : block
+        end
+
+        # The outer size of a block: its cells, the gaps between them and,
+        # outside a tree, a pad on every side.
+        def measure(block)
+          return tab_extent(block) if block.tabs?
+
+          columns = column_widths(block)
+          heights = block.rows.map { |row| row_height(block, row) }
+          return [columns.sum - TreeMarks::OVERHANG, heights.sum] if block.tree?
+
+          grid_size(block, columns, heights)
+        end
+
+        def grid_size(block, columns, heights)
+          room = group_room(block)
+          [grid_extent(columns) + overhang(block, columns) + room[0],
+           grid_extent(heights) + room[1]]
+        end
+
+        def grid_extent(sizes)
+          sizes.sum + (CELL_GAP * [sizes.size - 1, 0].max) + (2 * BLOCK_PAD)
+        end
+
+        def column_widths(block)
+          widths = []
+          block.rows.each do |row|
+            row.cells.each_with_index do |cell, index|
+              wide = cell_width(cell, block, row, index)
+              widths[index] = [widths[index].to_f, wide].max
+            end
+          end
+          widths
+        end
+
+        # The space before and after a tree cell's content. A tree row's
+        # first cell is pushed right by its depth; a nested block sits
+        # flush against its container.
+        def edges(cell, block, row, index)
+          return [0.0, 0.0] if !block.tree? || cell.is_a?(Block)
+
+          [tree_lead(row, index), TREE_PAD]
+        end
+
+        def tree_lead(row, index)
+          return TREE_PAD unless index.zero? && row.depth.positive?
+
+          row.depth * TREE_INDENT
+        end
+
+        def row_height(block, row)
+          floor = block.tree? ? TREE_ROW_HEIGHT : 0.0
+          row.cells.map { |cell| cell_height(cell, floor) }.max.to_f
+        end
+
+        def cell_height(cell, floor)
+          height = cell.is_a?(Block) ? measure(cell)[1] : widget_height(cell)
+          [height, floor].max
+        end
+
+        def cell_width(cell, block, row, index)
+          width = cell.is_a?(Block) ? measure(cell)[0] : widget_width(cell)
+          edges(cell, block, row, index).sum + width
+        end
+
+        def runs_width(runs)
+          runs.sum { |run| run_width(run) }
+        end
+
+        # PlantUML sets salt text in the platform's sans-serif, which is
+        # DejaVu Sans wherever its measurements were taken.
+        def run_width(run)
+          face = run.bold ? :dejavu_bold : :dejavu
+          TextMeasurement.measure_in(face, run.text,
+                                     font_size: run.size || FONT_SIZE)[:width]
+        end
+
+        def place(block, area)
+          return place_tabs(block, area) if block.tabs?
+
+          frame, origin = group_boxes(block, area)
+          columns = column_widths(block)
+          lefts, tops = slots(block, columns, origin)
+          place_rows(block, columns, lefts, tops)
+          return tree_decor(block, columns, area) if block.tree?
+          return group_frame(block, frame, lefts, tops) if framed?(block)
+
+          grid_rules(block, area, lefts, tops)
+        end
+
+        def framed?(block)
+          block.titled? || block.scroll?
+        end
+
+        # Where each column and each row starts.
+        def slots(block, columns, area)
+          pad = block.tree? ? 0.0 : BLOCK_PAD
+          gap = block.tree? ? 0.0 : CELL_GAP
+          heights = block.rows.map { |row| row_height(block, row) }
+          [offsets(columns, area.left + pad, gap),
+           offsets(heights, area.top + pad, gap)]
+        end
+
+        # The start of each size's slot when slots follow each other.
+        def offsets(sizes, from, gap)
+          sizes.each_with_object([from]) do |size, starts|
+            starts << (starts.last + size + gap)
+          end.first(sizes.size)
+        end
+
+        def place_rows(block, columns, lefts, tops)
+          block.rows.each_with_index do |row, line|
+            row.cells.each_with_index do |cell, index|
+              lead = edges(cell, block, row, index).first
+              place_cell(cell, lefts[index] + lead, tops[line], columns[index])
+            end
+          end
+        end
+
+        def place_cell(cell, left, top, reach)
+          return draw_widget(cell, left, top, reach) unless cell.is_a?(Block)
+
+          width, height = measure(cell)
+          place(cell, Box.new(left, top, width, height))
+        end
+
+        def text(runs, left, middle)
+          runs.each do |run|
+            box = Box.new(left, middle, run_width(run), 0.0)
+            @marks << Mark.new(:text, box, run: run)
+            left = box.right
+          end
+          left
+        end
+
+        def rule(left, top, width, height, **look)
+          Mark.new(:line, Box.new(left, top, width, height), **look)
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_salt/mark.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "box"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # One thing the renderer draws: a `:rect`, an `:ellipse` (inscribed in
+      # the box), a `:polygon` (its `points`), a `:line` (from the box's
+      # top-left to its bottom-right) or a `:text` (at the box's left edge,
+      # on the baseline `top`). `fill` is a shape's CSS paint; `ink`, when
+      # set, is the colour of its outline or line, `weight` its width and
+      # `radius` a rectangle's corner and `dash` a line's dash pattern.
+      class Mark
+        # The renderer sets a text on a baseline this far below its box.
+        TEXT_LIFT = 4.0
+
+        attr_reader :kind, :box, :run, :fill, :ink, :weight, :radius, :points,
+                    :dash
+
+        def initialize(kind, box, run: nil, points: nil, **look)
+          @kind = kind
+          @box = box
+          @run = run
+          @points = points
+          @fill = look.fetch(:fill, "none")
+          @ink = look[:ink]
+          @weight = look.fetch(:weight, 1.0)
+          @radius = look[:radius]
+          @dash = look[:dash]
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_salt/markup.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "run"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # Reads the inline markup salt shares with Creole: `<b>`, `<i>`,
+      # `<u>`, `<s>`, `<color:...>` and `<size:N>`. Any other angle-bracket
+      # text, such as `<P>`, is kept as literal text.
+      module Markup
+        TAG = %r{<(/?)(b|i|u|s|color|size)(?::([#\w]+))?>}i
+        UNTIL_TAG = /(?=#{TAG})|\z/
+        STYLE_KEYS = { "b" => :bold, "i" => :italic, "u" => :underline,
+                       "s" => :strike }.freeze
+        private_constant :TAG, :UNTIL_TAG, :STYLE_KEYS
+
+        module_function
+
+        # @param text [String]
+        # @return [Array<Run>] the styled runs, in source order
+        def runs(text)
+          state = {}
+          scanner = StringScanner.new(text)
+          found = []
+          until scanner.eos?
+            if scanner.scan(TAG) then apply(state, scanner)
+            else found << Run.new(scanner.scan_until(UNTIL_TAG), **state)
+            end
+          end
+          found
+        end
+
+        def apply(state, scanner)
+          key = STYLE_KEYS.fetch(scanner[2].downcase) do
+            scanner[2].downcase.to_sym
+          end
+          if scanner[1].empty?
+            state[key] = value(key, scanner[3])
+          else
+            state.delete(key)
+          end
+        end
+
+        # A style's value: a colour name, a size in points or just on.
+        def value(key, argument)
+          case key
+          when :color then argument
+          when :size then argument.to_i
+          else true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_salt/parser.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require_relative "block"
+require_relative "markup"
+require_relative "row"
+require_relative "run"
+require_relative "widget"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # Reads `@startsalt ... @endsalt` into a {Block} tree. Anything it does
+      # not recognise becomes plain text; it never raises on content.
+      class Parser
+        OPENER = %r{\A\{((?:S[I-]?)?[#+!\-*T/]*)(?:[ \t]+(.*))?\z}
+        # `{^Title`: the rest of the line heads the box.
+        TITLED = /\A\{\^(.*)\z/
+        START = /\A@startsalt(?![A-Za-z0-9_])/
+        CLOSE_TAIL = /\A\}\s*\|(.*)\z/
+        FINISH = /\A@endsalt\b/
+        INLINE_CLOSE = /\A([^{}]*?)\s*\}\s*\|(.*)\z/
+        CHECKBOX = /\A\[([xX ]?)\](?:[ \t]+(.*))?\z/
+        RADIO = /\A\(([xX ]?)\)(?:[ \t]+(.*))?\z/
+        BUTTON = /\A\[([^\]]+)\]\z/
+        FIELD = /\A"(.*)"\z/
+        DROPLIST = /\A\^(.*)\^\z/
+        # A line of its own: `..`, `==`, `--` or `~~`, which may carry a
+        # title closed by the same mark (`.. title ..`, dropped on draw).
+        RULE = /\A(\.\.|==|--|~~)(?:.*?\1)?\z/
+        RULE_VARIANTS = { ".." => :dotted, "==" => :double, "--" => :solid,
+                          "~~" => :heavy }.freeze
+        # `== Title`: a bold heading in the row's first cell.
+        HEADING = /\A==\s*(\S.*)\z/
+        HEADING_SIZE = 14
+        private_constant :OPENER, :TITLED, :CLOSE_TAIL, :START, :FINISH,
+                         :CHECKBOX, :RADIO, :BUTTON, :FIELD, :DROPLIST,
+                         :INLINE_CLOSE, :RULE, :RULE_VARIANTS, :HEADING,
+                         :HEADING_SIZE
+
+        # @param source [String] any String; invalid UTF-8 is scrubbed
+        # @return [Block] a root block holding every top-level row
+        def parse(source)
+          @root = Block.new("")
+          @stack = [@root]
+          body(source).each { |line| read_line(line) }
+          @root
+        end
+
+        private
+
+        def body(source)
+          text = source.dup.force_encoding(Encoding::UTF_8).scrub
+          lines = text.delete_prefix("\uFEFF").lines.map(&:strip)
+          inside(lines).reject(&:empty?)
+        end
+
+        # What lies between `@startsalt` and `@endsalt`, either of which
+        # may be absent.
+        def inside(lines)
+          from = lines.index { |line| START.match?(line) }
+          lines = lines.drop(from + 1) if from
+          stop = lines.index { |line| FINISH.match?(line) }
+          stop ? lines.first(stop) : lines
+        end
+
+        def read_line(line)
+          line, opened = open_blocks(line)
+          return if opened && inline_closed?(line)
+          return if closed_with_tail?(line)
+
+          line, closers = strip_closers(line)
+          add_row(line) unless line.empty?
+          closers.times { close_block }
+        end
+
+        # Opens every group the line starts with.
+        # @return [Array(String, Boolean)] what follows them and whether any
+        #   opened
+        def open_blocks(line)
+          opened = false
+          while (rest = open_block_on(line))
+            line = rest
+            opened = true
+          end
+          [line, opened]
+        end
+
+        # @return [String, nil] what follows the opener, nil when there is none
+        def open_block_on(line)
+          if (titled = TITLED.match(line))
+            open_block("^", title: heading_runs(titled[1].strip))
+            return ""
+          end
+          match = OPENER.match(line) or return
+
+          open_block(match[1])
+          match[2].to_s.strip
+        end
+
+        def heading_runs(text)
+          Markup.runs(text) unless text.empty?
+        end
+
+        # `{+ a | b } | c`: the block closes mid-line and `c` joins the
+        # row that holds the block.
+        def inline_closed?(line)
+          match = INLINE_CLOSE.match(line) or return false
+
+          add_row(match[1]) unless match[1].empty?
+          close_block
+          graft(match[2])
+          true
+        end
+
+        # `} | c`: the block closes and `c` joins the row that holds it.
+        def closed_with_tail?(line)
+          match = CLOSE_TAIL.match(line) or return false
+
+          close_block
+          graft(match[1])
+          true
+        end
+
+        def graft(tail)
+          host = @stack.last
+          row = host.rows.pop
+          cells = tail.split("|", -1).map { |cell| widget(cell.strip) }
+          host.rows << Row.new(row.cells + cells, depth: row.depth)
+        end
+
+        def strip_closers(line)
+          closers = 0
+          while line.start_with?("}") || closing_group?(line) ||
+              closing_row?(line)
+            line = line.delete_prefix("}").chomp("}").strip
+            closers += 1
+          end
+          [line, closers]
+        end
+
+        # `+ World }`: the `}` that ends a row closes the block holding it.
+        def closing_row?(line)
+          line.end_with?("}") && !line.include?("{")
+        end
+
+        def closing_group?(line)
+          line.end_with?("}") && line.start_with?("{")
+        end
+
+        def open_block(modifier, **)
+          block = Block.new(modifier, **)
+          @stack.last.rows << Row.new([block])
+          @stack.push(block)
+        end
+
+        def close_block
+          @stack.pop if @stack.size > 1
+        end
+
+        def add_row(line)
+          block = @stack.last
+          depth, line = nesting(block, line)
+          cells = (rule(line) unless block.tree?) || cells(line, block)
+          block.rows << Row.new(cells, depth: depth)
+        end
+
+        def rule(line)
+          match = RULE.match(line) or return
+
+          [Widget.new(:rule, variant: RULE_VARIANTS.fetch(match[1]))]
+        end
+
+        def cells(line, block)
+          cells = line.delete_prefix("|").split("|", -1)
+            .map { |cell| widget(cell.strip, tree: block.tree?) }
+          titled = HEADING.match(line) unless block.tree?
+          cells[0] = heading(titled[1]) if titled
+          cells
+        end
+
+        # The first cell's text, set as a heading in place of its `==`.
+        def heading(text)
+          title = text.split("|", 2).first.strip
+          Widget.new(:text, [Run.new(title, bold: true, size: HEADING_SIZE)])
+        end
+
+        # The depth a tree row's leading `+` marks give it, and the rest.
+        def nesting(block, line)
+          marks = block.tree? ? line[/\A\+*/] : ""
+          [marks.length, line.delete_prefix(marks).strip]
+        end
+
+        # In a tree table a quoted cell is the text itself, quotes
+        # included; elsewhere it is a text field.
+        def widget(text, tree: false)
+          return Widget.new(:empty) if text.empty?
+          return Widget.new(:empty, [Run.new(text)]) if text == "."
+
+          plain = tree && FIELD.match?(text)
+          (labelled(text) unless plain) || Widget.new(:text, Markup.runs(text))
+        end
+
+        def labelled(text)
+          toggle(:checkbox, CHECKBOX.match(text)) ||
+            toggle(:radio, RADIO.match(text)) ||
+            styled(:button, BUTTON.match(text)) ||
+            styled(:field, FIELD.match(text)) ||
+            droplist(DROPLIST.match(text))
+        end
+
+        def toggle(kind, match)
+          return unless match
+
+          Widget.new(kind, Markup.runs(match[2].to_s),
+                     checked: !match[1].strip.empty?)
+        end
+
+        def styled(kind, match)
+          labelled_widget(kind, match[1]) if match
+        end
+
+        # A label's spaces count toward the widget's size, not its text.
+        def labelled_widget(kind, label, **extra)
+          Widget.new(kind, Markup.runs(label.strip), **extra,
+                     chars: Markup.runs(label).sum { |run| run.text.length })
+        end
+
+        def droplist(match)
+          return unless match
+
+          label, *items = match[1].split("^")
+          items.reject! { |item| item.strip.empty? }
+          labelled_widget(:droplist, label.to_s,
+                          items: items.map { |item| Markup.runs(item) })
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_salt/renderer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "../../renderer/base"
+require_relative "../../svg"
+require_relative "layout"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # Draws a {Scene} the way PlantUML draws a salt window: black one-pixel
+      # rules and widgets as small outlined shapes.
+      class Renderer < Etassia::Renderer::Base
+        FONT_FAMILY = "sans-serif"
+        INK = "#000000"
+        NO_BREAK_SPACE = "\u00A0"
+        private_constant :FONT_FAMILY, :INK, :NO_BREAK_SPACE
+
+        # @param scene [Scene]
+        # @return [Svg::Document]
+        def render(scene)
+          Svg::Document.new(
+            width: scene.width, height: scene.height,
+            view_box: scene.view_box
+          ).tap do |document|
+            scene.marks.each { |mark| document << draw(mark) }
+          end
+        end
+
+        private
+
+        def draw(mark)
+          case mark.kind
+          when :rect then rectangle(mark)
+          when :ellipse then ellipse(mark)
+          when :polygon then polygon(mark)
+          when :line then rule(mark)
+          else text(mark)
+          end
+        end
+
+        def element(type, **attributes)
+          type.new.tap do |node|
+            attributes.each do |name, value|
+              node.public_send(:"#{name}=", value) unless value.nil?
+            end
+          end
+        end
+
+        def outline(mark)
+          { fill: mark.fill, stroke: mark.ink || INK,
+            stroke_width: mark.weight.to_s }
+        end
+
+        def rectangle(mark)
+          box = mark.box
+          element(Svg::Rect, x: box.left, y: box.top, width: box.width,
+                             height: box.height, rx: mark.radius,
+                             ry: mark.radius, **outline(mark))
+        end
+
+        def ellipse(mark)
+          radius = mark.box.width / 2
+          element(Svg::Ellipse, cx: mark.box.left + radius,
+                                cy: mark.box.top + radius, rx: radius,
+                                ry: radius, **outline(mark))
+        end
+
+        def polygon(mark)
+          points = mark.points.map { |pair| pair.map { |n| n.round(4) } }
+          element(Svg::Polygon, points: Svg::Polygon.build_points(points),
+                                **outline(mark))
+        end
+
+        def rule(mark)
+          box = mark.box
+          element(Svg::Line, x1: box.left, y1: box.top, x2: box.right,
+                             y2: box.bottom, stroke: mark.ink || INK,
+                             stroke_width: format("%g", mark.weight),
+                             stroke_dasharray: mark.dash)
+        end
+
+        # The width is the layout's, so a viewer's own sans-serif cannot
+        # move the text after it.
+        def text(mark)
+          run = mark.run
+          lead = edge_width(run, /\A\s*/)
+          trail = edge_width(run, /\s*\z/)
+          element(Svg::Text, content: content(run),
+                             **placement(mark, lead, trail),
+                             **typeface(run))
+        end
+
+        # A run of spaces is drawn as no-break spaces, as PlantUML does:
+        # SVG would collapse them to an empty node, and an underline or
+        # strike through them would vanish.
+        def content(run)
+          return run.text.strip unless run.text.strip.empty?
+
+          NO_BREAK_SPACE * run.text.length
+        end
+
+        def placement(mark, lead, trail)
+          box = mark.box
+          { x: (box.left + lead).round(4),
+            y: (box.top + Mark::TEXT_LIFT).round(4),
+            text_length: (box.width - lead - trail).round(4),
+            length_adjust: "spacing" }
+        end
+
+        def typeface(run)
+          { font_family: FONT_FAMILY,
+            font_size: (run.size || Layout::FONT_SIZE).to_s,
+            font_weight: ("bold" if run.bold),
+            font_style: ("italic" if run.italic), fill: run.color,
+            text_decoration: decoration(run) }
+        end
+
+        def decoration(run)
+          kinds = [("underline" if run.underline),
+                   ("line-through" if run.strike)].compact
+          kinds.join(" ") unless kinds.empty?
+        end
+
+        # SVG collapses a text element's edge spaces, so the leading ones
+        # are measured and added to x, and the trailing ones left out of
+        # the length, as PlantUML does.
+        def edge_width(run, edge)
+          return 0.0 if run.text.strip.empty?
+
+          lead = run.text[edge].length
+          TextMeasurement.measure_in(:dejavu, " " * lead,
+                                     font_size: run.size ||
+                                       Layout::FONT_SIZE)[:width]
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_salt/row.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # One line of a block: its cells (each a {Widget} or a nested {Block})
+      # and, in a tree block, how deep its `+` marks nest it.
+      class Row
+        attr_reader :depth, :cells
+
+        def initialize(cells, depth: 0)
+          @cells = cells.freeze
+          @depth = depth
+          freeze
+        end
+      end
+    end
+  end
+end