etassia 0.1.0

data/lib/etassia/notation/plantuml/activity/ranking.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # Decides which edges are loops and which row each node sits on.
+        # A depth-first walk from the first node marks an edge to a node
+        # still being walked as a back edge; the rest form a DAG, and a row
+        # is the longest path to it. A loop's exit must sit below the
+        # loop's body, so each back edge also holds the exits of its target
+        # beneath its source. An edge that lies along its row puts both its
+        # ends on one row.
+        class Ranking
+          # @return [Hash{Node => Integer}]
+          attr_reader :rank
+
+          def initialize(diagram)
+            @diagram = diagram
+            @out = Hash.new { |hash, key| hash[key] = [] }
+            diagram.edges.each { |edge| @out[edge.from] << edge }
+            @back = Set.new.compare_by_identity
+            walk
+            @rank = longest_paths(constraints)
+          end
+
+          # @return [Boolean] whether the edge closes a loop
+          def back?(edge)
+            @back.include?(edge)
+          end
+
+          # @return [Array<Edge>] edges leaving the node, loops excluded
+          def forward(node)
+            @out[node].reject { |edge| back?(edge) }
+          end
+
+          # @return [Boolean] whether the node sits between two rows: in the
+          #   legacy syntax, an `->` target whose own arrow runs two rows or
+          #   more further down is drawn half a row below its source
+          def parked?(node)
+            @diagram.legacy && @level_in.key?(node) &&
+              forward(node).any? { |edge| @rank[edge.to] - @rank[node] >= 2 }
+          end
+
+          # @return [Numeric] the row a node's box lies on: a parked node's
+          #   is half a row below its rank
+          def row(node)
+            parked?(node) ? @rank[node] + 0.5 : @rank[node]
+          end
+
+          # @return [Edge, nil] the edge that puts the node beside another
+          def level_in(node)
+            @level_in[node]
+          end
+
+          private
+
+          def walk
+            state = {}.compare_by_identity
+            @diagram.nodes.each do |node|
+              visit(node, state) unless state[node]
+            end
+          end
+
+          def visit(node, state)
+            state[node] = :open
+            @out[node].each do |edge|
+              case state[edge.to]
+              when :open then @back << edge
+              when nil then visit(edge.to, state)
+              end
+            end
+            state[node] = :done
+          end
+
+          # [from, to] pairs: every forward edge, and for each loop the
+          # exits of the loop head that cannot reach the loop's body.
+          def constraints
+            find_levels
+            forward_pairs + @back.flat_map { |edge| exit_pairs(edge) }
+          end
+
+          def forward_pairs
+            @diagram.edges.reject { |e| back?(e) || e.level? }
+              .map { |e| [e.from, e.to] }
+          end
+
+          def find_levels
+            @levels = @diagram.edges.select { |e| e.level? && !back?(e) }
+            @level_in = {}.compare_by_identity
+            @levels.reverse_each { |edge| @level_in[edge.to] = edge }
+          end
+
+          def exit_pairs(loop_edge)
+            forward(loop_edge.to).filter_map do |exit_edge|
+              next if reaches?(exit_edge.to, loop_edge.from)
+
+              [loop_edge.from, exit_edge.to]
+            end
+          end
+
+          def reaches?(from, target, seen = Set.new.compare_by_identity)
+            return true if from.equal?(target)
+            return false unless seen.add?(from)
+
+            forward(from).any? { |edge| reaches?(edge.to, target, seen) }
+          end
+
+          def longest_paths(pairs)
+            rank = @diagram.nodes.to_h { |node| [node, 0] }
+            rank.compare_by_identity
+            (@diagram.nodes.size + 1).times do
+              break if settle(rank, pairs).zero?
+            end
+            rank
+          end
+
+          # One pass over the constraints; the number of nodes it moved.
+          def settle(rank, pairs)
+            pairs.count { |from, to| lift(rank, from, to) } +
+              @levels.count { |edge| level(rank, edge.from, edge.to) }
+          end
+
+          # Puts both nodes on the lower of their two rows; nil when they
+          # already share one.
+          def level(rank, first, second)
+            return if rank[first] == rank[second]
+
+            rank[first] = rank[second] = [rank[first], rank[second]].max
+          end
+
+          # Puts `to` one row below `from`; nil when it already is.
+          def lift(rank, from, to)
+            return if rank[to] > rank[from]
+
+            rank[to] = rank[from] + 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/activity/reach.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "row_spread"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # How far each column reaches left and right of its centre, as a
+        # whole and row by row. A row is a rank, or half a rank past it for
+        # a parked node.
+        class Reach
+          # @return [Hash{Array => Array(Float, Float)}] the whole column
+          attr_reader :columns
+          # @return [Hash{Array => Hash{Numeric => Array(Float, Float)}}]
+          attr_reader :rows
+
+          # @param keys [Array<Array>] every column key
+          # @param by_row [Boolean] whether columns clear each other row by
+          #   row rather than as wholes
+          def initialize(keys, by_row: false)
+            @by_row = by_row
+            @columns = keys.to_h { |key| [key, [0.0, 0.0]] }
+            @rows = keys.to_h do |key|
+              [key, Hash.new { |rows, row| rows[row] = [0.0, 0.0] }]
+            end
+          end
+
+          # Widens a column, on one row, to at least `value` on a side.
+          # @param side [Integer] 0 for left, 1 for right
+          def grow(key, row, side, value)
+            [@columns[key], @rows[key][row]].each do |reach|
+              reach[side] = [reach[side], value].max
+            end
+          end
+
+          # Widens a whole column, and every row it has, by `extra` on a side.
+          # @param side [Integer] 0 for left, 1 for right
+          def widen_column(key, side, extra)
+            [@columns[key], *@rows[key].values].each do |reach|
+              reach[side] += extra
+            end
+          end
+
+          # Stands a line on a column's rows, as wide as nothing.
+          def line(key, rows)
+            rows.each { |row| grow(key, row, 0, 0.0) }
+          end
+
+          # @return [RowSpread, nil] nil unless the columns clear by row
+          def row_spread(margin)
+            RowSpread.new(@rows, @columns, margin) if @by_row
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "../../../renderer/base"
+require_relative "../../../svg"
+require_relative "../style"
+require_relative "layout"
+require_relative "../creole"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # Draws a {Scene}: each {Mark} becomes one SVG element, in order.
+        class Renderer < Etassia::Renderer::Base
+          FONT_FAMILY = "sans-serif"
+          PAPER = "#F1F1F1"
+          INK = "#181818"
+          TERMINAL = "#222222"
+          # The stroke width of the shapes PlantUML draws heavier than a box.
+          DRAWN_WIDTHS = { warning: "3", bar: "1" }.freeze
+          # How far a cubic stops short of the tip of its arrow head.
+          HEAD_NOTCH = 5.0
+          private_constant :FONT_FAMILY, :PAPER, :INK, :TERMINAL,
+                           :DRAWN_WIDTHS, :HEAD_NOTCH
+
+          # @param style [Style::Sheet] what the source sets; the drawn
+          #   defaults stand for anything it leaves out
+          def initialize(theme: nil, style: Style::Sheet.new)
+            super(theme: theme)
+            @style = style
+          end
+
+          # @param scene [Scene]
+          # @return [Svg::Document]
+          def render(scene)
+            Svg::Document.new(width: scene.width, height: scene.height,
+                              view_box: "0 0 #{scene.width} #{scene.height}")
+              .tap do |document|
+              scene.marks.each { |mark| document << draw(mark) }
+            end
+          end
+
+          private
+
+          def draw(mark)
+            send(:"draw_#{mark.kind}", mark.attrs)
+          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(attrs)
+            element(Svg::Rect, x: attrs[:x], y: attrs[:y], width: attrs[:width],
+                               height: attrs[:height],
+                               rx: corner(attrs),
+                               fill: fill(attrs),
+                               stroke: ink(attrs),
+                               stroke_width: frame_width(attrs),
+                               stroke_dasharray: look(:line_style))
+          end
+
+          def draw_circle(attrs)
+            element(Svg::Circle, cx: attrs[:cx], cy: attrs[:cy], r: attrs[:r],
+                                 fill: disc(attrs),
+                                 stroke: line_ink(attrs[:stroke]),
+                                 stroke_width: attrs[:width].to_s)
+          end
+
+          def draw_polygon(attrs)
+            head = attrs[:fill] == INK
+            element(Svg::Polygon, points: format_points(attrs[:points]),
+                                  fill: head ? arrow : fill(attrs),
+                                  stroke: head ? arrow : ink(attrs),
+                                  stroke_width: head ? "1" : hairline(attrs))
+          end
+
+          def draw_path(attrs)
+            data = path_data(attrs[:points], curve: attrs[:curve])
+            element(Svg::Path, d: data, fill: "none",
+                               stroke: line_ink(attrs[:stroke]),
+                               stroke_width: attrs[:width].to_s,
+                               stroke_dasharray: attrs[:dash])
+          end
+
+          def draw_text(attrs)
+            element(Svg::Text, x: attrs[:x], y: attrs[:y],
+                               content: attrs[:content],
+                               text_anchor: attrs[:anchor],
+                               font_family: attrs[:family] ||
+                                            face(attrs, :font_name) ||
+                                            FONT_FAMILY,
+                               font_size: attrs[:size].to_s,
+                               font_weight: attrs[:weight],
+                               fill: face(attrs, :font_colour) || "#000000")
+              .tap { |text| Creole.assign(text, attrs[:content]) }
+          end
+
+          def look(property)
+            @style.explicit(:activity, property)
+          end
+
+          # The rule of the mark's own `<style>` selector (diamond, note,
+          # partition, arrow), which wins over the activityDiagram block.
+          def own(attrs, property)
+            role = attrs[:role]
+            @style.explicit(role, property) if role
+          end
+
+          def face(attrs, property)
+            own(attrs, property) || look(property)
+          end
+
+          # A partition has no paint of its own, so only its own rule
+          # fills it; a diamond falls back to the action paint.
+          def fill(attrs)
+            own(attrs, :background) ||
+              (attrs[:role] == :partition ? attrs[:fill] : paper(attrs[:fill]))
+          end
+
+          # PlantUML draws a partition's corners at half the RoundCorner.
+          def corner(attrs)
+            return look(:round_corner) || attrs[:rx] unless
+              attrs[:role] == :partition
+
+            round = own(attrs, :round_corner)
+            round ? round / 2 : attrs[:rx]
+          end
+
+          def arrow
+            @style.explicit(:arrow, :border) ||
+              @style.from_style(:activity, :border) || INK
+          end
+
+          # The start disc takes the activityDiagram background.
+          def disc(attrs)
+            return attrs[:fill] unless attrs[:role] == :start
+
+            @style.from_style(:activity, :background) || attrs[:fill]
+          end
+
+          def hairline(attrs)
+            (own(attrs, :line_thickness) || look(:line_thickness) || 0.5).to_s
+          end
+
+          def frame_width(attrs)
+            unless attrs[:role] == :partition
+              return DRAWN_WIDTHS.fetch(attrs[:role]) { hairline(attrs) }
+            end
+
+            (own(attrs, :line_thickness) || 1.5).to_s
+          end
+
+          # The default box paint stands for what the source sets.
+          def paper(fill)
+            fill == PAPER ? look(:background) || fill : fill
+          end
+
+          def ink(attrs)
+            stroke = attrs[:stroke]
+            return stroke unless stroke == INK
+
+            own(attrs, :border) || look(:border) || stroke
+          end
+
+          def line_ink(stroke)
+            case stroke
+            when INK then arrow
+            when TERMINAL then @style.from_style(:activity, :border) || stroke
+            else stroke
+            end
+          end
+
+          def format_points(points)
+            points.map { |x, y| "#{number(x)},#{number(y)}" }.join(" ")
+          end
+
+          # PlantUML's cubic for a straight edge: control points a third of
+          # the way along, stopping short of the arrow head's notch.
+          def cubic(points)
+            from, to = points
+            to = shortened(from, to)
+            ctrl = [1, 2].map { |third| lerp(from, to, third / 3.0) }
+            curve = [*ctrl, to].map { |point| coords(point) }.join(" ")
+            "M#{coords(from)} C#{curve}"
+          end
+
+          def lerp(from, to, fraction)
+            from.zip(to).map { |a, b| a + ((b - a) * fraction) }
+          end
+
+          def shortened(from, to)
+            length = Math.hypot(to.first - from.first, to.last - from.last)
+            lerp(from, to, [(length - HEAD_NOTCH) / length, 0.0].max)
+          end
+
+          def coords(point)
+            point.map { |value| number(value) }.join(",")
+          end
+
+          def path_data(points, curve: false)
+            return cubic(points) if curve && points.size == 2
+
+            points.each_with_index.map do |(x, y), index|
+              "#{index.zero? ? 'M' : 'L'}#{number(x)},#{number(y)}"
+            end.join(" ")
+          end
+
+          def number(value)
+            value.round(2).to_s.delete_suffix(".0")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/activity/route.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # The drawn path of one edge and where its label goes.
+        class Route
+          attr_reader :points, :label_x, :label_y, :anchor
+
+          # @param points [Array<Array(Float, Float)>] corners, start to tip
+          def initialize(points:, label_x:, label_y:, anchor: "start")
+            @points = points
+            @label_x = label_x
+            @label_y = label_y
+            @anchor = anchor
+          end
+        end
+      end
+    end
+  end
+end