etassia 0.1.0

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # A stretch of text drawn in one style. `style` may hold `:bold`,
+      # `:italic`, `:underline`, `:strike` (true), `:color` (a String) and
+      # `:size` (a Numeric, in points).
+      class Run
+        attr_reader :text
+
+        def initialize(text, **style)
+          @text = text
+          @style = style.freeze
+          freeze
+        end
+
+        %i[bold italic underline strike].each do |name|
+          define_method(name) { @style.fetch(name, false) }
+        end
+
+        # @return [Numeric, nil] the font size, when it is not the default
+        def size
+          @style[:size]
+        end
+
+        # @return [String, nil] a colour name or hex digits
+        def color
+          @style[:color]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # The laid-out diagram: canvas size and its marks, back to front.
+      class Scene
+        attr_reader :width, :height, :marks
+
+        def initialize(width:, height:, marks:)
+          @width = width
+          @height = height
+          @marks = marks.freeze
+          freeze
+        end
+
+        def view_box
+          "0 0 #{width} #{height}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "box"
+require_relative "mark"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # The `{S` group's scroll bars: a strip beside the frame (or below
+      # it) with a rule and an arrow at each end.
+      module ScrollMarks
+        # A scroll bar: a 15-wide strip four units from the frame, and
+        # eleven units further that the group reserves beyond it.
+        BAR_GAP = 4.0
+        BAR_WIDTH = 15.0
+        BAR_ROOM = BAR_GAP + BAR_WIDTH + 11.0
+        BAR_END = 12.0
+        # An arrow in a bar points at the bar's edge: its tip and its base
+        # sit this far in from it, at the start of the bar and at its end,
+        # and it is six across; the bar's centre line is 7 in.
+        ARROW_START = [4.0, 9.0].freeze
+        ARROW_END = [3.0, 8.0].freeze
+        ARROW_HALF = 3.0
+        BAR_AXIS = 7.0
+        BAR_BLACK = "#000000"
+
+        private
+
+        def vertical_bar(frame)
+          bar = Box.new(frame.right + BAR_GAP, frame.top, BAR_WIDTH,
+                        frame.height)
+          bar_body(bar, vertical_ends(bar))
+          axis = bar.left + BAR_AXIS
+          bar_arrows([axis, bar.top], [axis, bar.bottom], [0.0, 1.0])
+        end
+
+        def horizontal_bar(frame)
+          bar = Box.new(frame.left, frame.bottom + BAR_GAP, frame.width,
+                        BAR_WIDTH)
+          bar_body(bar, horizontal_ends(bar))
+          axis = bar.top + BAR_AXIS
+          bar_arrows([bar.left, axis], [bar.right, axis], [1.0, 0.0])
+        end
+
+        def vertical_ends(bar)
+          [bar.top + BAR_END, bar.bottom - BAR_END].map do |y|
+            rule(bar.left, y, BAR_WIDTH, 0.0)
+          end
+        end
+
+        def horizontal_ends(bar)
+          [bar.left + BAR_END, bar.right - BAR_END].map do |x|
+            rule(x, bar.top, 0.0, BAR_WIDTH)
+          end
+        end
+
+        # The strip and the rules that close off its ends.
+        def bar_body(bar, ends)
+          @marks << Mark.new(:rect, bar, ink: BAR_BLACK)
+          @marks.concat(ends)
+        end
+
+        # The arrows at the bar's start and end; `heading` is the unit step
+        # from the start towards the end.
+        def bar_arrows(start, finish, heading)
+          bar_arrow(start, heading, ARROW_START)
+          bar_arrow(finish, heading.map { |step| 0.0 - step }, ARROW_END)
+        end
+
+        # A triangle on the bar's `edge` point, pointing away from it along
+        # `heading` (a unit step on one axis); `reach` is the tip's and the
+        # base's distance from the edge.
+        def bar_arrow(edge, heading, reach)
+          @marks << Mark.new(:polygon, Box.new(*edge, 0.0, 0.0),
+                             fill: BAR_BLACK, ink: BAR_BLACK,
+                             points: arrow_points(edge, heading, reach))
+        end
+
+        def arrow_points(edge, heading, reach)
+          dx, dy = heading
+          tip, base = reach.map do |far|
+            [edge[0] + (dx * far), edge[1] + (dy * far)]
+          end
+          sideways = [dy.abs * ARROW_HALF, dx.abs * ARROW_HALF]
+          [tip, shift(base, sideways, 1), shift(base, sideways, -1)]
+        end
+
+        def shift(point, by, sign)
+          [point[0] + (sign * by[0]), point[1] + (sign * by[1])]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "mark"
+require_relative "widget"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # The `{/` group: a row of tabs side by side, each open at the bottom
+      # and joined to the next by a baseline rule.
+      module TabMarks
+        # A tab: its text sits two units in and the tab ends three units
+        # past it; the baseline rule runs ten units on to the next tab.
+        TAB_LEFT = 2.0
+        TAB_PAD = 5.0
+        TAB_RUN = 10.0
+
+        private
+
+        # A tab row's size: tabs side by side, each with its baseline rule.
+        def tab_extent(block)
+          widths = block.rows.map { |row| row.cells.sum { |c| tab_width(c) } }
+          lines = block.rows.map { |row| tab_line(row) }
+          [widths.max.to_f, stacked(lines)]
+        end
+
+        def stacked(lines)
+          lines.sum + (GridMarks::CELL_GAP * [lines.size - 1, 0].max)
+        end
+
+        def tab_runs(cell)
+          cell.is_a?(Widget) ? cell.runs : []
+        end
+
+        def tab_width(cell)
+          runs_width(tab_runs(cell)) + TAB_PAD + TAB_RUN
+        end
+
+        def tab_line(row)
+          line_of(row.cells.map { |cell| runs_size(tab_runs(cell)) }.max)
+        end
+
+        def place_tabs(block, area)
+          top = area.top
+          block.rows.each do |row|
+            line = tab_line(row)
+            row.cells.inject(area.left) do |left, cell|
+              tab(tab_runs(cell), left, top, line)
+            end
+            top += line + GridMarks::CELL_GAP
+          end
+        end
+
+        # A tab open at the bottom; the baseline rule runs on to the next
+        # tab. Returns where that is.
+        def tab(runs, left, top, line)
+          width = runs_width(runs) + TAB_PAD
+          text(runs, left + TAB_LEFT, top + runs_drop(runs))
+          tab_outline(left, top, width, line)
+          left + width + TAB_RUN
+        end
+
+        def tab_outline(left, top, width, line)
+          [[left, top, 0.0, line],
+           [left, top, width, 0.0],
+           [left + width, top, 0.0, line],
+           [left + width, top + line, TAB_RUN, 0.0]].each do |edge|
+            @marks << rule(*edge)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "box"
+require_relative "font_metrics"
+require_relative "mark"
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # What PlantUML adds around a `{T` tree table, in its own grey: a
+      # small node mark on every row that has children, an elbow
+      # connector from each row up to its parent, and the rules the
+      # modifier asks for (`!` column bars, `-` row rules, `#` both, `+`
+      # a frame). A bar or rule runs the full width or height, edges
+      # included.
+      module TreeMarks
+        TREE_INK = "#888888"
+        NODE = 2.0
+        NODE_RISE = 1.0
+        ELBOW_GAP = 2.0
+        NODE_LEFT = 6.0
+        ROW_HEIGHT = FontMetrics::HEIGHT
+        PAD = 5.0
+        INDENT = 10.0
+        # The table counts this much less toward its container than the
+        # bars it draws span.
+        OVERHANG = 3.0
+
+        private
+
+        def tree_decor(block, columns, area)
+          tops = row_tops(block, area)
+          connectors(block, tops, area)
+          rules(block, columns, area, tops)
+        end
+
+        def row_tops(block, area)
+          top = area.top
+          block.rows.map do |row|
+            top.tap { top += row_height(block, row) }
+          end << top
+        end
+
+        def connectors(block, tops, area)
+          rows = block.rows
+          rows.each_index do |index|
+            parent = parent_index(rows, index)
+            node(rows, index, tops, area) if parent_of?(rows, index)
+            elbow(rows, parent, index, tops, area) if parent
+          end
+        end
+
+        def parent_index(rows, index)
+          depth = rows[index].depth
+          return if depth < 2
+
+          (index - 1).downto(0).find { |back| rows[back].depth < depth }
+        end
+
+        def parent_of?(rows, index)
+          rows[index].depth.positive? && rows[index + 1] &&
+            rows[index + 1].depth > rows[index].depth
+        end
+
+        def centre_y(tops, index)
+          (tops[index] + tops[index + 1]) / 2
+        end
+
+        def centre_x(row, area)
+          area.left + (row.depth * INDENT) - NODE_LEFT
+        end
+
+        def node(rows, index, tops, area)
+          x = centre_x(rows[index], area)
+          y = centre_y(tops, index)
+          box = Box.new(x - NODE_RISE, y - NODE_RISE, NODE, NODE)
+          @marks << Mark.new(:rect, box, ink: TREE_INK)
+        end
+
+        def elbow(rows, parent, index, tops, area)
+          x = centre_x(rows[parent], area)
+          from = centre_y(tops, parent) + NODE
+          to = centre_y(tops, index)
+          @marks << grey(x, from, 0.0, to - from)
+          @marks << grey(x, to, reach(rows[index], area) - x, 0.0)
+        end
+
+        def reach(row, area)
+          centre_x(row, area) - ELBOW_GAP
+        end
+
+        def grey(left, top, width, height)
+          Mark.new(:line, Box.new(left, top, width, height), ink: TREE_INK)
+        end
+
+        def rules(block, columns, area, tops)
+          drawn = Box.new(area.left, area.top, columns.sum, area.height)
+          frame(drawn) if block.border?
+          bars(columns, area) if block.grid? || block.column_lines?
+          bands(tops, drawn) if block.grid? || block.row_lines?
+        end
+
+        # Four rules, as PlantUML draws it: top, bottom, left, right.
+        def frame(area)
+          [area.top, area.bottom].each do |y|
+            @marks << grey(area.left, y, area.width, 0.0)
+          end
+          [area.left, area.right].each do |x|
+            @marks << grey(x, area.top, 0.0, area.height)
+          end
+        end
+
+        def bands(tops, area)
+          tops.each { |top| @marks << grey(area.left, top, area.width, 0.0) }
+        end
+
+        def bars(columns, area)
+          left = area.left
+          [0.0, *columns].each do |width|
+            left += width
+            @marks << grey(left, area.top, 0.0, area.height)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUMLSalt
+      # One leaf of a salt row: plain text, a button, a text field and so on.
+      class Widget
+        KINDS = %i[text button field checkbox radio droplist empty
+                   rule].freeze
+
+        attr_reader :kind, :runs, :checked, :items, :variant, :chars
+
+        # @param kind [Symbol] one of {KINDS}
+        # @param runs [Array<Run>] the visible label, in order
+        # @param checked [Boolean] whether a checkbox or radio is ticked
+        # @param extra [Hash] what only some kinds carry:
+        # @option extra [Array<Array<Run>>] :items a droplist's further choices
+        # @option extra [Symbol] :variant a rule's kind: `:dotted`, `:double`,
+        #   `:solid` or `:heavy`
+        # @option extra [Integer] :chars the characters the label took in the
+        #   source, spaces included; PlantUML sizes a button, field or
+        #   droplist by these
+        def initialize(kind, runs = [], checked: false, **extra)
+          @kind = kind
+          @chars = extra.fetch(:chars) { runs.sum { |run| run.text.length } }
+          @runs = runs.freeze
+          @checked = checked
+          @items = extra.fetch(:items, []).freeze
+          @variant = extra[:variant]
+          freeze
+        end
+
+        # @return [String] the label with its markup removed
+        def text
+          runs.map(&:text).join
+        end
+      end
+    end
+  end
+end