etassia 0.1.0

data/lib/etassia/notation/plantuml_data/boxes/highlights.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # The `#highlight "a" / "b" <<class>>` lines of a JSON or YAML
+        # diagram and the `<style>` that colours them.
+        class Highlights
+          DIRECTIVE = /\A#highlight[ \t]+(.+?)(?:[ \t]+<<(\w+)>>)?\z/i
+          STYLE = %r{<style>(.*?)</style>}mi
+          RULE = /([.\w]+)[ \t]*\{([^{}]*)\}/
+          FIELDS = { "backgroundcolor" => :background, "fontcolor" => :color,
+                     "fontstyle" => :style }.freeze
+          DEFAULT = { background: "#CCFF02", color: "#000000",
+                      style: nil }.freeze
+          private_constant :DIRECTIVE, :STYLE, :RULE, :FIELDS, :DEFAULT
+
+          # Splits the highlight lines and style off the data.
+          #
+          # @param text [String] the lines between `@start` and `@end`
+          # @return [Array(Highlights, String)] the highlights and the rest
+          def self.extract(text)
+            styles = text.scan(STYLE).flatten.join("\n")
+            rest = text.gsub(STYLE, "")
+            lines, data = rest.lines.partition { |l| DIRECTIVE.match?(l.strip) }
+            [new(lines.map(&:strip), styles), data.join]
+          end
+
+          def initialize(directives = [], style_text = "")
+            @styles = parse_styles(style_text)
+            @paths = directives.map { |line| parse_directive(line) }
+          end
+
+          # @param path [Array<String>] keys from the root to a row
+          # @return [Hash, nil] `:background`, `:color` and `:style`
+          def style_for(path)
+            found = @paths.find { |keys, _| keys == path }
+            found && style_of(found.last)
+          end
+
+          private
+
+          def parse_directive(line)
+            body, name = DIRECTIVE.match(line).captures
+            [body.scan(/"((?:[^"\\]|\\.)*)"/).flatten, name]
+          end
+
+          def style_of(name)
+            DEFAULT.merge(@styles.fetch(name, @styles.fetch("highlight", {})))
+          end
+
+          def parse_styles(text)
+            text.scan(RULE).to_h do |selector, body|
+              [selector.delete_prefix("."), fields(body)]
+            end
+          end
+
+          def fields(body)
+            body.lines.filter_map do |line|
+              name, value = line.strip.split(/[ \t]+/, 2)
+              field = FIELDS[name.to_s.downcase]
+              [field, value.strip] if field && value
+            end.to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/inline_rows.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "marks"
+require_relative "text"
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # Measures and draws the rows of a `json` element mixed into another
+        # diagram. PlantUML draws such an element as one box: a nested object
+        # or array fills the value cell of its row as rows of its own, and
+        # an object keeps a key column of its own width.
+        module InlineRows
+          extend self
+
+          ROW = 20.4883
+          PAD = 5.0
+
+          # @return [Float] the key column width plus the widest value cell
+          def width(rows)
+            key_width(rows) + (rows.map { |row| cell_width(row) }.max || 0.0)
+          end
+
+          # @return [Float] what the rows stack to
+          def height(rows)
+            rows.sum { |row| row.inline ? height(row.inline.rows) : ROW }
+          end
+
+          # @return [Float] the key column's width, 0 when no row is keyed
+          def key_width(rows)
+            return 0.0 unless rows.any?(&:key)
+
+            rows.filter_map { |row| Text.width(row.key) if row.key }.max +
+              (2 * PAD)
+          end
+
+          # @param width [Float] what the rows fill, at least {#width}
+          # @return [Array<Hash>] the marks of rows whose corner is at
+          #   `left`, `top`
+          def draw(rows, left, top, width)
+            keys = key_width(rows)
+            split = left + keys
+            marks = keys.positive? ? divider(split, top, height(rows)) : []
+            rows.each_with_index.reduce([top, marks]) do |(y, out), (row, i)|
+              out.concat(row_marks(row, [left, y, width], split, i))
+              [y + row_height(row), out]
+            end.last
+          end
+
+          private
+
+          def cell_width(row)
+            return width(row.inline.rows) if row.inline
+
+            Text.width(row.value) + (2 * PAD)
+          end
+
+          def row_height(row)
+            row.inline ? height(row.inline.rows) : ROW
+          end
+
+          def divider(split, top, height)
+            [Marks.line([split, top], [split, top + height],
+                        stroke: Marks::INK)]
+          end
+
+          def row_marks(row, frame, split, index)
+            left, top, width = frame
+            [*rule(left, top, width, index),
+             *key_mark(row, left, top),
+             *value_marks(row, [split, top, left + width])]
+          end
+
+          def rule(left, top, width, index)
+            return [] unless index.positive?
+
+            [Marks.line([left, top], [left + width, top], stroke: Marks::INK)]
+          end
+
+          def key_mark(row, left, top)
+            return [] unless row.key
+
+            [Marks.text(row.key, left + PAD, top + (ROW / 2))]
+          end
+
+          def value_marks(row, frame)
+            split, top, right = frame
+            if row.inline
+              return draw(row.inline.rows, split, top, right - split)
+            end
+
+            [Marks.text(row.value, split + PAD, top + (ROW / 2))]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/json_reader.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../../../error/parse_error"
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # Reads the JSON of a `@startjson` diagram.
+        class JsonReader
+          # @return [Hash, Array, String, Numeric, true, false, nil]
+          # @raise [Etassia::Parser::ParseError] when the text is not JSON
+          def call(text)
+            JSON.parse(text, max_nesting: 100, allow_nan: false)
+          rescue JSON::ParserError => e
+            raise Etassia::Parser::ParseError,
+                  "Parse error: JSON: #{e.message[0, 120]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/link_text.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "marks"
+require_relative "text"
+require_relative "../../../text_measurement"
+require_relative "../../plantuml/label_clearance"
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # The texts of a relation, placed as the JAR does: the label of a
+        # steep line starts just right of its middle, the label of a flat one
+        # is centred on its middle with its foot on the line's highest point
+        # under it, the text of an end finishes just left of it, a line's
+        # height from that end.
+        module LinkText
+          extend self
+
+          LABEL_GAP = 1.0
+          LABEL_DROP = 5.2
+          END_GAP = 1.4
+          TAIL_DROP = 20.2
+          HEAD_RISE = 10.4
+          # How far right of the middle a flat line's label is centred, and
+          # how far its baseline rises over the line (0.264 of the font).
+          FLAT_SHIFT = 2.8
+          FLAT_RISE = 3.7
+
+          # @return [Array<Hash>] text marks for `link`, drawn from `start`
+          #   to `stop`
+          def call(link, start, stop)
+            [label(link, start, stop), tail(link, start),
+             head(link, stop)].compact
+          end
+
+          private
+
+          def label(link, start, stop)
+            return if link.label.to_s.empty?
+            return flat_label(link.label, start, stop) if flat?(start, stop)
+
+            steep_label(link.label, start, stop)
+          end
+
+          def flat?(start, stop)
+            (stop[0] - start[0]).abs > (stop[1] - start[1]).abs
+          end
+
+          def flat_label(content, start, stop)
+            centre = ((start[0] + stop[0]) / 2) + FLAT_SHIFT
+            half = width_of(content) / 2
+            top = PlantUML::LabelClearance.top_between(
+              start, stop, centre - half, centre + half
+            )
+            text(content, centre, top - FLAT_RISE, "middle")
+          end
+
+          # Right of the line, past its furthest point under the text.
+          def steep_label(content, start, stop)
+            middle = ((start[1] + stop[1]) / 2) + LABEL_DROP
+            reach = PlantUML::LabelClearance.right_between(
+              start, stop, middle - Text::FONT_SIZE, middle
+            )
+            text(content, [reach, (start[0] + stop[0]) / 2].max + LABEL_GAP,
+                 middle)
+          end
+
+          # Measured in DejaVu Sans, the face the picture is drawn in.
+          def width_of(content)
+            TextMeasurement.measure_in(:dejavu, Text.plain(content),
+                                       font_size: Text::FONT_SIZE)[:width]
+          end
+
+          def tail(link, start)
+            text(link.tail_text, start[0] - END_GAP, start[1] + TAIL_DROP,
+                 "end")
+          end
+
+          def head(link, stop)
+            text(link.head_text, stop[0] - END_GAP, stop[1] - HEAD_RISE, "end")
+          end
+
+          def text(content, left, baseline, anchor = nil)
+            return if content.to_s.empty?
+
+            Marks.text(content, left, baseline - Marks::BASELINE,
+                       anchor: anchor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/marks.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "text"
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # Builds the marks both layouts draw boxes, rules, text and arrows
+        # with. PlantUML's palette: grey fill, black ink.
+        module Marks
+          extend self
+
+          INK = "#181818"
+          BLACK = "#000000"
+          PAPER = "#F1F1F1"
+          # How far a text's baseline lies below its vertical middle.
+          BASELINE = 5.5
+
+          def rect(left, top, width, height, **style)
+            { kind: :rect, x: left, y: top, width: width, height: height,
+              rx: 5, fill: PAPER, stroke: INK, stroke_width: 1.5 }.merge(style)
+          end
+
+          def line(from, to, stroke: BLACK, width: 1)
+            { kind: :line, x1: from[0], y1: from[1], x2: to[0], y2: to[1],
+              stroke: stroke, stroke_width: width }
+          end
+
+          # @param middle [Float] the y of the text's vertical middle
+          # @param style [Hash] bold, italic, fill and anchor
+          def text(content, left, middle, **style)
+            { kind: :text, content: content, x: left, y: middle + BASELINE,
+              bold: false, italic: false, fill: BLACK, anchor: nil }
+              .merge(style)
+          end
+
+          def curve(from, to, dashed: false, stroke: BLACK)
+            { kind: :path, d: bezier(from, to), dashed: dashed,
+              stroke: stroke }
+          end
+
+          def polygon(points, fill: BLACK, stroke: fill)
+            { kind: :polygon, points: points, fill: fill, stroke: stroke }
+          end
+
+          # The small notched arrow PlantUML ends a tree link with: 7.6 long,
+          # 6.1 wide, notched 2.3 in from its base; filled, never outlined.
+          def arrowhead(tip)
+            x, y = tip
+            polygon([[x - 7.6, y - 3.0], [x - 5.3, y], [x - 7.6, y + 3.0], tip],
+                    fill: BLACK, stroke: "none")
+          end
+
+          def dot(centre)
+            { kind: :circle, cx: centre[0], cy: centre[1], r: 3, fill: BLACK }
+          end
+
+          private
+
+          def bezier(from, to)
+            start, *rest = [from, *handles(from, to), to].map do |point|
+              point.join(" ")
+            end
+            "M #{start} C #{rest.join(' ')}"
+          end
+
+          def handles(from, to)
+            reach = [(to[0] - from[0]).abs / 2.0, 13.0].max
+            [[from[0] + reach, from[1]], [to[0] - reach, to[1]]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/ornaments.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "marks"
+require_relative "text"
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # What a cell's markup draws that a text element cannot: the
+        # background of `<back:..>`, the coloured line of `<s:..>` and
+        # `<u:..>`, an Open Iconic glyph, and a placeholder where an emoji
+        # goes (Twemoji is CC-BY 4.0 and its set is too large to bundle).
+        module Ornaments
+          extend self
+
+          # Open Iconic outlines sit on an 8 grid; PlantUML scales them by
+          # the font size over this.
+          ICON_SCALE = 12.0
+          ICON_LIFT = 9.88
+          ICON_NUDGE = 0.75
+          BACK_LIFT = 13.0
+          BACK_HEIGHT = 16.5
+          STRIKE_LIFT = 3.5
+          UNDER_DROP = 1.0
+          EMOJI_BOX = 14.0
+          DRAWN = %i[back strike_colour underline_colour icon emoji].freeze
+          private_constant :DRAWN
+          # @return [Array<Hash>] the marks to draw under a text mark
+          def behind(mark)
+            each_piece(mark).filter_map do |piece, left, right|
+              colour = piece.style[:back]
+              next unless colour
+
+              Marks.rect(left, mark[:y] - BACK_LIFT, right - left, BACK_HEIGHT,
+                         rx: 0, fill: css(colour), stroke: "none",
+                         stroke_width: 0)
+            end
+          end
+
+          # @return [Array<Hash>] the marks to draw over a text mark
+          def over(mark)
+            each_piece(mark).flat_map do |piece, left, right|
+              [*picture(piece, mark, left, right),
+               *rule(piece, :strike_colour, mark[:y] - STRIKE_LIFT,
+                     [left, right]),
+               *rule(piece, :underline_colour, mark[:y] + UNDER_DROP,
+                     [left, right])]
+            end
+          end
+
+          private
+
+          def each_piece(mark)
+            return [] unless mark[:kind] == :text && mark[:content]
+
+            runs = Text.runs(mark[:content])
+            return [] if runs.all? { |piece| plain?(piece) }
+
+            spans(runs, mark)
+          end
+
+          def plain?(piece)
+            !piece.style.keys.intersect?(DRAWN)
+          end
+
+          def spans(runs, mark)
+            widths = runs.map { |piece| Text.width(piece.text) }
+            left = mark[:x] - anchor_shift(mark[:anchor], widths.sum)
+            runs.zip(widths).map do |piece, width|
+              span = [piece, left, left + width]
+              left += width
+              span
+            end
+          end
+
+          def anchor_shift(anchor, total)
+            anchor == "middle" ? total / 2 : 0.0
+          end
+
+          def rule(piece, key, height, span)
+            return [] unless piece.style[key]
+
+            [Marks.line([span[0], height], [span[1], height],
+                        stroke: css(piece.style[key]), width: 0.5)]
+          end
+
+          def picture(piece, mark, left, right)
+            if piece.style[:icon]
+              [icon(piece.style[:icon], left, mark[:y], mark[:fill])]
+            elsif piece.style[:emoji]
+              [placeholder(left, right, mark[:y])]
+            else
+              []
+            end
+          end
+
+          def icon(name, left, baseline, fill)
+            { kind: :glyph, d: outline(name),
+              fill: fill,
+              transform: place(left + ICON_NUDGE, baseline - ICON_LIFT) }
+          end
+
+          # Loaded on first use, like {Text}: `require "etassia"` must not
+          # define the PlantUML namespace.
+          def outline(name)
+            require_relative "../../plantuml/creole_icons"
+            Etassia::Notation::PlantUML::Creole::Icons.outline(name)
+          end
+
+          def place(left, top)
+            format("translate(%<x>.4f %<y>.4f) scale(%<k>.4f)",
+                   x: left, y: top, k: Text::FONT_SIZE / ICON_SCALE)
+          end
+
+          def placeholder(left, right, baseline)
+            side = EMOJI_BOX
+            Marks.rect(left + ((right - left - side) / 2), baseline - side,
+                       side, side, rx: 3, fill: "none", stroke: Marks::INK,
+                                   stroke_width: 0.5)
+          end
+
+          def css(colour)
+            colour.match?(/\A\h{3}(?:\h{3})?\z/) ? "##{colour}" : colour
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/renderer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../../../renderer/base"
+require_relative "../../../svg"
+require_relative "ornaments"
+require_relative "text"
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # Draws a {Scene} the way PlantUML does: grey boxes with black
+        # rules, dashed links in a JSON or YAML tree.
+        class Renderer < Etassia::Renderer::Base
+          FONT = "sans-serif"
+          private_constant :FONT
+
+          # @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 do |mark|
+                [*Ornaments.behind(mark), mark, *Ornaments.over(mark)]
+                  .each { |piece| document << draw(piece) }
+              end
+            end
+          end
+
+          private
+
+          def draw(mark)
+            send(:"draw_#{mark[:kind]}", mark)
+          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 draw_rect(mark)
+            element(Svg::Rect, **mark.slice(:x, :y, :width, :height, :rx, :fill,
+                                            :stroke, :stroke_width),
+                    ry: mark[:rx])
+          end
+
+          def draw_line(mark)
+            element(Svg::Line,
+                    **mark.slice(:x1, :y1, :x2, :y2, :stroke, :stroke_width))
+          end
+
+          def draw_text(mark)
+            element(Svg::Text, x: mark[:x], y: mark[:y], fill: mark[:fill],
+                               font_family: FONT, font_size: "14",
+                               font_weight: ("bold" if mark[:bold]),
+                               font_style: ("italic" if mark[:italic]),
+                               text_anchor: mark[:anchor])
+              .tap { |text| Text.assign(text, mark[:content]) }
+          end
+
+          def draw_path(mark)
+            element(Svg::Path, d: mark[:d], fill: "none", stroke: mark[:stroke],
+                               stroke_width: "1",
+                               stroke_dasharray: dashes(mark))
+          end
+
+          def dashes(mark)
+            mark[:dash] || "3,3" if mark[:dashed]
+          end
+
+          def draw_glyph(mark)
+            element(Svg::Path, d: mark[:d], fill: mark[:fill],
+                               transform: mark[:transform])
+          end
+
+          def draw_polygon(mark)
+            element(Svg::Polygon, points: Svg::Polygon.build_points(mark[:points]),
+                                  fill: mark[:fill], stroke: mark[:stroke],
+                                  stroke_width: "1")
+          end
+
+          def draw_circle(mark)
+            element(Svg::Circle, cx: mark[:cx], cy: mark[:cy], r: mark[:r],
+                                 fill: mark[:fill],
+                                 stroke: mark.fetch(:stroke, mark[:fill]),
+                                 stroke_width: "1")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/row_alignment.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # Where the JAR stands a box that is alone in its rank and linked
+        # with a row of a map: beside the side its line leaves by, or, when
+        # it is the one linking to the row, over the middle of the map.
+        class RowAlignment
+          # How far from the side of a map the middle of such a box lies.
+          DRIFT = 5.5
+
+          # @param links [Array<Link>]
+          def initialize(links)
+            @links = links
+          end
+
+          # @param rects [Hash{String => Rect}] each box where it stands
+          # @param alone [Array<String>] the boxes alone in their rank
+          # @return [Hash{String => Rect}] `rects`, the alone boxes moved
+          #   across
+          def call(rects, alone)
+            rects.to_h do |id, rect|
+              middle = alone.include?(id) && middle_of(id, rects)
+              [id, middle ? rect.with(x: middle - (rect.width / 2)) : rect]
+            end
+          end
+
+          private
+
+          def middle_of(id, rects)
+            from_row(id, rects) || over_map(id, rects)
+          end
+
+          def from_row(id, rects)
+            link = @links.find { |l| l.to == id && l.from_row.is_a?(String) }
+            link && side(link, rects.fetch(link.from))
+          end
+
+          def over_map(id, rects)
+            link = @links.find { |l| l.from == id && l.to_row }
+            link && rects.fetch(link.to).centre[0]
+          end
+
+          # Just past the side a map's row leaves by: the left one when
+          # another line already ends at the row, otherwise the right.
+          def side(link, rect)
+            taken = @links.any? do |other|
+              other.to == link.from && other.to_row == link.from_row
+            end
+            taken ? rect.x - DRIFT : rect.right + DRIFT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml_data/boxes/row_bend.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUMLData
+      module Boxes
+        # The two handles of the spline a link to or from a map row is drawn
+        # as: it leaves a row by its side, square to it, and meets a box edge
+        # head on.
+        module RowBend
+          extend self
+
+          REACH = 30.0
+          EASE = 0.35
+
+          # @param ends [Array<Array<Float>>] where the line starts and stops
+          # @param rows [Array<Boolean>] whether each end is a row of its box
+          # @param centres [Array<Array<Float>>] the middle of each end's box
+          # @return [Array<Array<Float>>] the handle of the start, then of
+          #   the stop
+          def handles(ends, rows, centres)
+            [0, 1].map do |at|
+              point = ends[at]
+              other = ends[1 - at]
+              next square(point, other, centres[at]) if rows[at]
+
+              [point[0], point[1] + ((other[1] - point[1]) * EASE)]
+            end
+          end
+
+          private
+
+          # A point out from the side of the box `point` is on.
+          def square(point, other, centre)
+            reach = [(other[0] - point[0]).abs / 2, REACH].max
+            side = point[0] >= centre[0] ? 1 : -1
+            [point[0] + (side * reach), point[1]]
+          end
+        end
+      end
+    end
+  end
+end