etassia 0.1.0

data/lib/etassia/notation/plantuml/tree/layout.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require_relative "../../../layout/mindmap"
+require_relative "reader"
+require_relative "role"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Tree
+        # One laid-out node of a tree: the box it draws and the text in it.
+        class Node < Etassia::Layout::Mindmap::Node
+          attribute :boxed, :boolean
+          attribute :fill, :string
+          attribute :corner_radius, :float
+          attribute :stroke, :string
+          attribute :stroke_width, :float
+          attribute :dasharray, :string
+          attribute :font_colour, :string
+        end
+
+        # A connector, as the path it draws.
+        class Edge < Etassia::Layout::Mindmap::Edge
+          attribute :stroke_width, :float
+          attribute :stroke, :string
+          attribute :dasharray, :string
+        end
+
+        # What a tree layout hands its renderer.
+        class Scene < Etassia::Layout::Scene
+          attribute :view_box, :string
+          attribute :children, Node, collection: true, default: -> { [] }
+          attribute :edges, Edge, collection: true, default: -> { [] }
+        end
+
+        # The part of a PlantUML tree layout that mindmaps and work breakdown
+        # structures share: it reads the hierarchy graph into a forest, sizes
+        # each box from its text, and returns the finished scene. The
+        # Mermaid mindmap layout it extends is a force layout; a subclass
+        # supplies the tree one through {#place_tree}.
+        #
+        # @abstract
+        class Layout < Etassia::Layout::Mindmap
+          MARGIN = 20.0
+          PAD_X = 10.0
+          PAD_Y = 10.0
+          LINE_RATIO = 1.1777
+          BASELINE_RATIO = 0.9667
+          # DejaVu Sans Mono, the JAR's `monospace`: line height and ascent.
+          MONO_LINE_RATIO = 1.1641
+          MONO_BASELINE_RATIO = 0.928
+          FILL = "#F1F1F1"
+          private_constant :MARGIN, :PAD_X, :PAD_Y, :LINE_RATIO,
+                           :BASELINE_RATIO, :FILL,
+                           :MONO_LINE_RATIO, :MONO_BASELINE_RATIO
+
+          # A node of the forest with its text measured.
+          Item = Struct.new(:id, :level, :side, :boxless, :fill, :lines,
+                            :width, :height, :children, :mono)
+          # A placed box.
+          Box = Struct.new(:item, :x, :y) do
+            def right
+              x + item.width
+            end
+
+            def mid_y
+              y + (item.height / 2.0)
+            end
+          end
+          private_constant :Item, :Box
+
+          # @param rules [Rules] what the source's `<style>` blocks set
+          # @return [Class] this layout, drawing with those rules
+          def self.styled(rules)
+            return self unless rules.any?
+
+            Class.new(self) { define_method(:rules) { rules } }
+          end
+
+          private
+
+          def rules
+            @rules ||= Rules.new
+          end
+
+          def scene(graph)
+            @boxes = []
+            @segments = []
+            @depths = []
+            @row_end = nil
+            top = MARGIN
+            forest(graph).each do |root|
+              top = place_tree(root, top) + gap_between_trees
+            end
+            build_scene
+          end
+
+          def font_size
+            raise NotImplementedError
+          end
+
+          def gap_between_trees
+            raise NotImplementedError
+          end
+
+          # @return [Float] the bottom of the placed tree
+          def place_tree(_root, _top)
+            raise NotImplementedError
+          end
+
+          def line_height
+            font_size * LINE_RATIO
+          end
+
+          def forest(graph)
+            by_parent = graph.nodes.group_by(&:parent_id)
+            by_parent.fetch(nil, []).map { |node| item(node, by_parent, 1) }
+          end
+
+          def item(node, by_parent, level)
+            children = by_parent.fetch(node.id, []).map do |child|
+              item(child, by_parent, level + 1)
+            end
+            sized_item(node, level, children)
+          end
+
+          def sized_item(node, level, children)
+            role = Role.parse(node.role)
+            lines, mono = text_lines(node)
+            width, height = measured(lines, mono, boxless: role.boxless)
+            Item.new(node.id, level, role.side, role.boxless, role.fill, lines,
+                     width, height, children, mono)
+          end
+
+          def text_lines(node)
+            lines = node.label.to_s.split("\n", -1)
+            lines = [""] if lines.empty?
+            [lines.map { |line| line.delete_prefix(Reader::MONO_MARK) },
+             lines.map { |line| line.start_with?(Reader::MONO_MARK) }]
+          end
+
+          def measured(lines, mono, boxless: false)
+            widest = lines.zip(mono).map do |line, mono_line|
+              line_width(line, mono_line)
+            end.max
+            [widest + (2 * PAD_X),
+             mono.sum { |mono_line| pitch(mono_line) } + (2 * pad_y(boxless))]
+          end
+
+          def line_width(line, mono)
+            return measure_text(line, font_size: font_size)[:width] unless mono
+
+            TextMeasurement.measure_mono(line, font_size: font_size)[:width]
+          end
+
+          def pitch(mono)
+            mono ? font_size * MONO_LINE_RATIO : line_height
+          end
+
+          # The room above and below a box's text; a boxless node's own
+          # layout may keep it tighter.
+          def pad_y(boxless)
+            boxless ? boxless_pad_y : PAD_Y
+          end
+
+          def boxless_pad_y
+            PAD_Y
+          end
+
+          def box(item, left, top)
+            Box.new(item, left, top).tap { |placed| @boxes << placed }
+          end
+
+          # @param depth [Integer] the depth of the parent the line leaves
+          def segment(from_x, from_y, to_x, to_y, depth)
+            curve("M#{from_x.round(3)},#{from_y.round(3)} " \
+                  "L#{to_x.round(3)},#{to_y.round(3)}", depth)
+          end
+
+          def curve(path, depth)
+            @segments << path
+            @depths << depth
+          end
+
+          def build_scene
+            shift = MARGIN - @boxes.map(&:x).min.to_f
+            width, height = scene_size(shift)
+            Scene.new(width: width, height: height,
+                      view_box: "0 0 #{width.round(3)} #{height.round(3)}",
+                      children: @boxes.map { |b| node(b, shift) },
+                      edges: edges(shift))
+          end
+
+          def scene_size(shift)
+            [(@boxes.map(&:right).max + shift) + MARGIN,
+             @boxes.map { |b| b.y + b.item.height }.max + MARGIN]
+          end
+
+          def edges(shift)
+            @segments.each_with_index.map do |path, index|
+              Edge.new(id: "link#{index}", path: shift_path(path, shift),
+                       **connector_look(@depths[index]))
+            end
+          end
+
+          def connector_look(depth)
+            look = rules.arrow(depth)
+            { stroke_width: look.fetch(:stroke_width, stroke_width),
+              stroke: look[:stroke], dasharray: look[:dasharray] }
+          end
+
+          def stroke_width
+            1.0
+          end
+
+          # Every number pair in a path is an `x,y` point.
+          def shift_path(path, shift)
+            path.gsub(/(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)/) do
+              px = Regexp.last_match(1).to_f + shift
+              "#{px.round(3)},#{Regexp.last_match(2)}"
+            end
+          end
+
+          def node(placed, shift)
+            item = placed.item
+            left = placed.x + shift
+            Node.new(id: item.id, level: item.level,
+                     labels: [label(item, left, placed.y)],
+                     **box_geometry(placed, left), **appearance(item))
+          end
+
+          def box_geometry(placed, left)
+            item = placed.item
+            { x: left, y: placed.y, width: item.width, height: item.height,
+              center_x: left + (item.width / 2.0), center_y: placed.mid_y }
+          end
+
+          def appearance(item)
+            look = rules.node(item.level - 1, boxless: item.boxless)
+            { shape: item.boxless ? "boxless" : "default",
+              boxed: !item.boxless, fill: item.fill || look[:fill] || FILL,
+              corner_radius: corner_of(look) }.merge(
+                look.slice(:stroke, :stroke_width, :dasharray, :font_colour),
+              )
+          end
+
+          def corner_radius
+            0.0
+          end
+
+          # PlantUML draws a corner of half the RoundCorner it is given.
+          def corner_of(look)
+            look[:round_corner] ? look[:round_corner] / 2.0 : corner_radius
+          end
+
+          def label(item, left_edge, top)
+            left = left_edge + PAD_X
+            first = top + pad_y(item.boxless) + (font_size * BASELINE_RATIO)
+            Label.new(text: item.lines.join("\n"), x: left, y: first.round(3),
+                      font_size: font_size,
+                      lines: positioned_lines(item, left, top + PAD_Y))
+          end
+
+          def positioned_lines(item, left, line_top)
+            item.lines.zip(item.mono).map do |text, mono|
+              ascent = mono ? MONO_BASELINE_RATIO : BASELINE_RATIO
+              LabelLine.new(text: text, x: left, mono: mono,
+                            y: (line_top + (font_size * ascent)).round(3))
+                .tap { line_top += pitch(mono) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/tree/mindmap_layout.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "layout"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Tree
+        # PlantUML's mindmap: the root in the middle, its right-hand
+        # branches growing right and its left-hand ones growing left, every
+        # parent centred on its children and joined to them by a curve.
+        class MindmapLayout < Layout
+          SIBLING_GAP = 20.0
+          LEVEL_GAP = 50.0
+          LEAD = 10.0
+          BEND = 25.0
+          private_constant :SIBLING_GAP, :LEVEL_GAP, :LEAD, :BEND
+
+          private
+
+          def font_size
+            14.0
+          end
+
+          def gap_between_trees
+            SIBLING_GAP
+          end
+
+          def corner_radius
+            12.5
+          end
+
+          # A subtree measured on its own: where each child sits relative to
+          # the item's centre, and how far the subtree reaches above and
+          # below that centre at each depth.
+          Subtree = Struct.new(:item, :children, :offsets, :contour)
+          private_constant :Subtree
+
+          def place_tree(root, top)
+            sides = fan_sides(root)
+            half = root.height / 2.0
+            low, high = extent(sides, half)
+            centre = top - low
+            place_sides(box(root, 0.0, centre - half), sides)
+            centre + high
+          end
+
+          def extent(sides, half)
+            reach = sides.flat_map { |(_, _, deep), _| deep.flatten }
+            [[reach.min, -half].compact.min, [reach.max, half].compact.max]
+          end
+
+          def fan_sides(root)
+            right, left = root.children.partition { |c| c.side == "right" }
+            [[fan(right), 1], [fan(left), -1]]
+          end
+
+          def place_sides(hub, sides)
+            sides.each do |(subs, offsets, _), direction|
+              place(hub, subs, offsets, direction)
+            end
+          end
+
+          def tree(item)
+            subs, offsets, deep = fan(item.children)
+            half = item.height / 2.0
+            Subtree.new(item, subs, offsets, [[-half, half]] + deep)
+          end
+
+          # Subtrees of siblings packed top to bottom, each as close to the
+          # one before as their contours allow, and centred on the middle of
+          # what they cover. Returns [subtrees, offsets from that middle,
+          # contour about it].
+          def fan(items)
+            subs = items.map { |item| tree(item) }
+            return [subs, [], []] if subs.empty?
+
+            [subs, *recentre(*stack(subs))]
+          end
+
+          def recentre(offsets, covered)
+            mid = (covered.flatten.min + covered.flatten.max) / 2.0
+            [offsets.map { |o| o - mid },
+             covered.map { |top, bottom| [top - mid, bottom - mid] }]
+          end
+
+          def stack(subs)
+            offsets = []
+            covered = []
+            subs.each do |sub|
+              offset = covered.empty? ? 0.0 : clearance(covered, sub.contour)
+              offsets << offset
+              absorb(covered, sub.contour, offset)
+            end
+            [offsets, covered]
+          end
+
+          def clearance(covered, contour)
+            shared = [covered.length, contour.length].min
+            (0...shared).map do |depth|
+              covered[depth].last + SIBLING_GAP - contour[depth].first
+            end.max
+          end
+
+          def absorb(covered, contour, offset)
+            contour.each_with_index do |(top, bottom), depth|
+              reach = [top + offset, bottom + offset]
+              covered[depth] = if covered[depth]
+                                 [[covered[depth].first, reach.first].min,
+                                  [covered[depth].last, reach.last].max]
+                               else
+                                 reach
+                               end
+            end
+          end
+
+          def place(parent, subs, offsets, direction)
+            subs.zip(offsets).each do |sub, offset|
+              child = child_box(parent, sub.item, direction,
+                                parent.mid_y + offset)
+              join(parent, child, direction)
+              place(child, sub.children, sub.offsets, direction)
+            end
+          end
+
+          def child_box(parent, item, direction, centre)
+            left = if direction.positive?
+                     parent.right + LEVEL_GAP
+                   else
+                     parent.x - LEVEL_GAP - item.width
+                   end
+            box(item, left, centre - (item.height / 2.0))
+          end
+
+          def join(parent, child, direction)
+            start = direction.positive? ? parent.right : parent.x
+            stop = direction.positive? ? child.x : child.right
+            curve(connector(start, parent.mid_y, stop, child.mid_y, direction),
+                  parent.item.level - 1)
+          end
+
+          def connector(from_x, from_y, to_x, to_y, direction)
+            lead = direction * LEAD
+            bend = direction * BEND
+            "M#{point(from_x, from_y)} L#{point(from_x + lead, from_y)} " \
+              "C#{point(from_x + bend, from_y)} #{point(to_x - bend, to_y)} " \
+              "#{point(to_x - lead, to_y)} L#{point(to_x, to_y)}"
+          end
+
+          def point(x_pos, y_pos)
+            "#{x_pos.round(3)},#{y_pos.round(3)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/tree/reader.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+require_relative "../source_lines"
+require_relative "../unsupported_construct_error"
+require_relative "role"
+require_relative "rules"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Tree
+        # Reads a PlantUML mindmap or work breakdown structure into the
+        # hierarchy graph Etassia's mindmap already uses.
+        #
+        # A line is a run of `*` (or `+` and `-`, which also pick the side of
+        # the root) followed by the text; the run's length is the depth. A
+        # `:` in place of the space opens a multi-line text closed by a line
+        # ending in `;`. A `_` after the run draws no box, a `[#colour]`
+        # fills the box, and `<<name>>` at the end of the text applies the
+        # `.name` colour of a `<style>` block. A `<style>` block's other
+        # rules are kept in {#rules}. A line outside this subset raises
+        # {UnsupportedConstructError}.
+        class Reader
+          ITEM = /\A([*+-]+)([<>])?(_)?(?:\[(\#?\w+)\])?(:|[ \t])[ \t]*(.*)\z/
+          SKIPPED = /\A(?:title|header|footer|caption|legend|skinparam|scale|
+                     !theme|hide|show|left[ ]to[ ]right[ ]direction|
+                     top[ ]to[ ]bottom[ ]direction)\b/xi
+          STYLE_OPEN = /\A<style>/i
+          STYLE_CLOSE = %r{</style>\z}i
+          CLASS_STYLE = /\.(\w+)[ \t]*\{([^{}]*)\}/m
+          BACKGROUND = /BackgroundColor[ \t]+(\#?\w+)/i
+          TRAILING_CLASS = /[ \t]*<<(\w+)>>\z/
+          CODE_TAG = %r{\A</?code>\z}i
+          # A line of a `<code>` block carries this mark in front, which the
+          # layout reads back as "draw in the monospace family".
+          MONO_MARK = "\u{E000}"
+          private_constant :ITEM, :SKIPPED, :STYLE_OPEN, :STYLE_CLOSE,
+                           :CLASS_STYLE, :BACKGROUND, :TRAILING_CLASS,
+                           :CODE_TAG
+
+          # One line of the source, as read.
+          Entry = Struct.new(:id, :depth, :side, :boxless, :fill, :lines,
+                             :parent, keyword_init: true)
+          private_constant :Entry
+
+          # @return [Rules] what the source's `<style>` blocks set
+          attr_reader :rules
+
+          # @param source [String] PlantUML source
+          # @param id [String] the graph's id, which names the kind
+          # @return [Etassia::IR::Graph]
+          # @raise [UnsupportedConstructError] on a line outside the subset
+          def parse(source, id:)
+            @entries = []
+            @rules = Rules.new
+            @classes = {}
+            @open = nil
+            @code = false
+            @style = nil
+            SourceLines.of(source).each { |text, number| read(text, number) }
+            IR::Graph.new(id: id, role: "hierarchy", nodes: nodes,
+                          edges: edges)
+          end
+
+          private
+
+          def read(text, number)
+            return continue_text(text) if @open
+            return style_line(text) if @style
+            return if SKIPPED.match?(text)
+            return style_line(text.sub(STYLE_OPEN, ""), opening: true) if
+              STYLE_OPEN.match?(text)
+
+            item = ITEM.match(text)
+            raise refused(text, number) unless item
+
+            start_item(item)
+          end
+
+          def refused(text, number)
+            UnsupportedConstructError.new(
+              construct: "mindmap statement", line: number, text: text,
+            )
+          end
+
+          def style_line(text, opening: false)
+            @style = [] if opening
+            @style << text.sub(STYLE_CLOSE, "")
+            close_style if STYLE_CLOSE.match?(text)
+          end
+
+          def close_style
+            @rules.add(@style.join("\n"))
+            sheet = @style.join("\n").gsub(%r{//[^\n]*}, "")
+            sheet.scan(CLASS_STYLE) do |name, properties|
+              colour = BACKGROUND.match(properties)
+              @classes[name] = colour[1] if colour
+            end
+            @style = nil
+          end
+
+          def start_item(match)
+            marks, hang, boxless, colour, joint, rest = match.captures
+            entry = Entry.new(depth: marks.length, boxless: !boxless.nil?,
+                              fill: colour, lines: [])
+            attach(entry, marks[0], hang)
+            settle(entry, joint, rest)
+          end
+
+          def settle(entry, joint, rest)
+            return @open = entry.tap { entry.lines << rest } if
+              joint == ":" && !rest.end_with?(";")
+
+            finish(entry, joint == ":" ? rest.delete_suffix(";") : rest)
+          end
+
+          def continue_text(text)
+            return @code = !text.start_with?("</") if CODE_TAG.match?(text)
+            return @open.lines << marked(text) unless text.end_with?(";")
+
+            entry = @open
+            @open = nil
+            last = text == ";" ? "" : marked(text.delete_suffix(";"))
+            @code = false
+            finish(entry, last, continued: true)
+          end
+
+          def marked(text)
+            @code ? "#{MONO_MARK}#{text}" : text
+          end
+
+          def finish(entry, last, continued: false)
+            entry.lines.pop if continued && entry.lines.last.to_s.empty?
+            entry.lines << last
+            entry.lines[-1] = classed(entry, entry.lines.last)
+            entry
+          end
+
+          def classed(entry, text)
+            match = TRAILING_CLASS.match(text)
+            return text unless match
+
+            entry.fill ||= @classes[match[1]]
+            text.sub(TRAILING_CLASS, "")
+          end
+
+          # The parent is the nearest earlier entry one level up; a first
+          # level entry is a root of its own.
+          def attach(entry, mark, hang)
+            entry.id = "n#{@entries.length + 1}"
+            entry.parent = @entries.reverse.find do |other|
+              other.depth < entry.depth
+            end
+            entry.side = side_of(entry.parent, mark, hang)
+            @entries << entry
+          end
+
+          def side_of(parent, mark, hang)
+            return "left" if mark == "-" || hang == "<"
+            return "right" if mark == "+" || hang == ">"
+
+            parent ? parent.side : "right"
+          end
+
+          def nodes
+            @entries.map do |entry|
+              role = Role.spell(side: entry.side, boxless: entry.boxless,
+                                fill: entry.fill)
+              IR::Node.new(id: entry.id, label: entry.lines.join("\n"),
+                           parent_id: entry.parent&.id, role: role)
+            end
+          end
+
+          def edges
+            @entries.select(&:parent).map do |entry|
+              IR::Edge.new(id: "#{entry.parent.id}_to_#{entry.id}",
+                           source_id: entry.parent.id, target_id: entry.id,
+                           role: "parent_child")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/tree/renderer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../../../renderer/mindmap"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Tree
+        # Draws a PlantUML tree: grey boxes with a dark outline, text set
+        # from the left of the box, and thin dark connectors under them. The
+        # Mermaid mindmap renderer it extends draws coloured, centred shapes.
+        class Renderer < Etassia::Renderer::Mindmap
+          INK = "#181818"
+          INK_TEXT = "#000000"
+          FONT = "sans-serif"
+          MONO_FONT = "monospace"
+          private_constant :INK, :INK_TEXT, :FONT, :MONO_FONT
+
+          protected
+
+          def render_connection(edge, svg)
+            svg.add_element(Svg::Path.new.tap do |path|
+              path.d = edge.path
+              path.stroke = edge.stroke || INK
+              path.stroke_width = edge.stroke_width.to_s
+              path.stroke_dasharray = edge.dasharray
+              path.fill = "none"
+            end)
+          end
+
+          def render_node(node, svg)
+            group = Svg::Group.new
+            group.add_child(outline(node)) if node.boxed
+            label = node.labels.first
+            label.lines.each do |line|
+              group.add_child(text_line(line, label.font_size,
+                                        node.font_colour || INK_TEXT))
+            end
+            svg.add_element(group)
+          end
+
+          private
+
+          def outline(node)
+            Svg::Rect.new(x: node.x, y: node.y, width: node.width,
+                          height: node.height, rx: node.corner_radius,
+                          ry: node.corner_radius, fill: node.fill,
+                          stroke: node.stroke || INK,
+                          stroke_width: (node.stroke_width || 1.5).to_s,
+                          stroke_dasharray: node.dasharray)
+          end
+
+          def text_line(line, size, colour)
+            Svg::Text.new.tap do |text|
+              text.x = line.x
+              text.y = line.y
+              text.content = line.text
+              text.fill = colour
+              text.font_size = size.to_s
+              text.font_family = line.mono ? MONO_FONT : FONT
+            end
+          end
+        end
+      end
+    end
+  end
+end