etassia 0.1.0

data/lib/etassia/notation/plantuml/sequence/fragment_shape.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "scene"
+require_relative "tab_size"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # The frame of an alt/loop/group block: the box, the keyword tab in
+        # its top left corner, the guard text and one dashed line per `else`.
+        # `block` is the Walker's record of the block.
+        class FragmentShape
+          TAB_PAD = 8.0
+          TAB_HEIGHT = 20.0
+          BASE_PAD = 10.0
+          NEST_PAD = 8.0
+          BRANCH_BASELINE = 10.7
+          private_constant :BRANCH_BASELINE
+
+          attr_reader :x, :width
+
+          # The keyword tab hanging in the top left corner of a frame.
+          def self.tab_outline(left, top, width, height = TAB_HEIGHT)
+            right = left + width
+            bottom = top + height
+            "M #{left} #{top} L #{right} #{top} L #{right} #{bottom - 6} " \
+              "L #{right - 6} #{bottom} L #{left} #{bottom} Z"
+          end
+
+          def initialize(block, bottom, centers, measure, appearance)
+            @block = block
+            @bottom = bottom
+            @measure = measure
+            @appearance = appearance
+            low, high = extent(block, centers)
+            pad = BASE_PAD + (NEST_PAD * block[:depth])
+            @x = low - pad
+            @width = [high - low + (2 * pad), minimum_width].max
+          end
+
+          def scene
+            Scene::Fragment.new(
+              x: x, y: @block[:top], width: width,
+              height: @bottom - @block[:top], tab_path: tab_path,
+              tab_fill: @appearance.tab_fill,
+              separators: separators, texts: texts
+            )
+          end
+
+          private
+
+          # A block no item touched spans the whole diagram.
+          def extent(block, centers)
+            return [centers.first, centers.last] if block[:low] > block[:high]
+
+            [block[:low], block[:high]]
+          end
+
+          def group?
+            @block[:keyword] == "group"
+          end
+
+          def tab_text
+            return @block[:keyword] unless group? && !guard.empty?
+
+            guard
+          end
+
+          def guard
+            @block[:label]
+          end
+
+          def bracket(label)
+            label.empty? || group? ? nil : "[#{label}]"
+          end
+
+          def tab
+            @block.fetch(:tab) { TabSize.new(nil, 1) }
+          end
+
+          def tab_width
+            (@measure.call(tab_text) * tab.scale) + (2 * TAB_PAD)
+          end
+
+          def minimum_width
+            guard_width = @measure.call(bracket(guard).to_s)
+            tab_width + guard_width + (3 * TAB_PAD)
+          end
+
+          def tab_path
+            self.class.tab_outline(x, @block[:top], tab_width,
+                                   TAB_HEIGHT + tab.height_growth)
+          end
+
+          def separators
+            @block[:branches].map do |y, _label|
+              PlantUML::Scene::Segment.new(x1: x, y1: y, x2: x + width, y2: y)
+            end
+          end
+
+          def texts
+            top = @block[:top] + 14 + tab.baseline_growth
+            [tab_label(top), *guard_texts(top), *branch_texts]
+          end
+
+          def tab_label(top)
+            text(tab_text, x + TAB_PAD, top, "fragment_tab").tap do |label|
+              label.colour = @appearance.tab_colour
+              label.size = tab.size if tab.custom?
+            end
+          end
+
+          def guard_texts(top)
+            label = bracket(guard)
+            return [] unless label
+
+            [text(label, x + tab_width + TAB_PAD, top, "fragment_guard")]
+          end
+
+          def branch_texts
+            @block[:branches].filter_map do |y, label|
+              next if label.to_s.strip.empty?
+
+              text("[#{label}]", x + TAB_PAD,
+                   y + BRANCH_BASELINE, "fragment_guard")
+            end
+          end
+
+          def text(content, at_x, at_y, role)
+            PlantUML::Scene::Text.new(content: content, x: at_x, y: at_y,
+                                      role: role, anchor: "start")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/head_style.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # What a `participant { ... }` style block sets on the heads:
+        # `colour` and `size` of the label, its `style`, `family` and
+        # `weight`, and the `line` colour round the head. Each is nil until
+        # the source sets it.
+        class HeadStyle
+          KEYS = %i[colour size style family weight line].freeze
+          private_constant :KEYS
+
+          attr_reader(*KEYS)
+
+          def initialize(**settings)
+            unknown = settings.keys - KEYS
+            raise ArgumentError, "unknown: #{unknown}" if unknown.any?
+
+            KEYS.each { |key| instance_variable_set(:"@#{key}", settings[key]) }
+            freeze
+          end
+
+          # @return [HeadStyle] this one with each setting `other` made
+          def merge(other)
+            HeadStyle.new(**KEYS.to_h { |key| [key, other.pick(key, self)] })
+          end
+
+          def empty?
+            KEYS.all? { |key| public_send(key).nil? }
+          end
+
+          protected
+
+          def pick(key, fallback)
+            public_send(key) || fallback.public_send(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_adapter/blocks.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRAdapter
+          # Encodes every item that is not a message.
+          module Blocks
+            module_function
+
+            def note(note, sink, ids)
+              node = sink.node("note", note.text)
+              sink.detail(node, "shape", note.shape)
+              sink.detail(node, "side", note.side)
+              sink.detail(node, "parallel", "true") if note.parallel?
+              Fills.call(node, note.fill, sink)
+              targets(node, note.targets, sink, ids)
+            end
+
+            def ref(ref, sink, ids)
+              targets(sink.node("ref", ref.label), ref.targets, sink, ids)
+            end
+
+            def fragment(fragment, sink, _ids)
+              node = sink.node("fragment", fragment.label)
+              sink.detail(node, "phase", fragment.phase)
+              sink.detail(node, "keyword", fragment.keyword)
+              sink.detail(node, "parallel", "true") if fragment.parallel?
+            end
+
+            def divider(divider, sink, _ids)
+              sink.node("divider", divider.label)
+            end
+
+            def delay(delay, sink, _ids)
+              sink.node("delay", delay.label)
+            end
+
+            def spacing(spacing, sink, _ids)
+              sink.detail(sink.node("spacing"), "height", spacing.height)
+            end
+
+            def activation(activation, sink, ids)
+              node = sink.node("activation")
+              sink.detail(node, "phase", activation.phase)
+              sink.detail(node, "colour", activation.color)
+              targets(node, [activation.participant], sink, ids)
+            end
+
+            def destroy(destroy, sink, ids)
+              targets(sink.node("destroy"), [destroy.participant], sink, ids)
+            end
+
+            def create(create, sink, ids)
+              targets(sink.node("create"), [create.participant], sink, ids)
+            end
+
+            def page_break(_break, sink, _ids)
+              sink.node("page_break")
+            end
+
+            def targets(node, names, sink, ids)
+              names.each do |name|
+                sink.edge("target", node, ids.fetch(name), parent_id: node.id)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_adapter/fills.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRAdapter
+          # Encodes the colour written after a participant or a note.
+          module Fills
+            module_function
+
+            # @param fill [Fill, nil] nothing is written for nil
+            def call(parent, fill, sink)
+              return unless fill
+
+              sink.detail(parent, "fill_colour", fill.colour)
+              sink.detail(parent, "fill_opacity", fill.opacity)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_adapter/items.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../activation"
+require_relative "../create"
+require_relative "../delay"
+require_relative "../destroy"
+require_relative "../divider"
+require_relative "../fragment"
+require_relative "../message"
+require_relative "../note"
+require_relative "../page_break"
+require_relative "../ref"
+require_relative "../spacing"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRAdapter
+          # Encodes the items of the diagram, in source order.
+          module Items
+            ENCODERS = [[Message, Messages.method(:call)],
+                        [Note, Blocks.method(:note)],
+                        [Ref, Blocks.method(:ref)],
+                        [Fragment, Blocks.method(:fragment)],
+                        [Divider, Blocks.method(:divider)],
+                        [Delay, Blocks.method(:delay)],
+                        [Spacing, Blocks.method(:spacing)],
+                        [Activation, Blocks.method(:activation)],
+                        [Destroy, Blocks.method(:destroy)],
+                        [Create, Blocks.method(:create)],
+                        [PageBreak, Blocks.method(:page_break)]].freeze
+            private_constant :ENCODERS
+
+            module_function
+
+            def call(diagram, sink, ids)
+              diagram.items.each do |item|
+                encoder = ENCODERS.find { |type, _| item.is_a?(type) }
+                encoder.last.call(item, sink, ids)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_adapter/messages.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRAdapter
+          # Encodes a message: a node that holds its place in the order and
+          # its drawing facts, and an edge from sender to receiver.
+          module Messages
+            module_function
+
+            def call(message, sink, ids)
+              node = sink.node("message", message.label)
+              details(message, node, sink)
+              style = message.style
+              sink.edge("message", end_node(message.from, node, sink, ids),
+                        end_node(message.to, node, sink, ids),
+                        parent_id: node.id, properties: markers(style))
+            end
+
+            def details(message, node, sink)
+              style = message.style
+              sink.detail(node, "number", message.number&.text)
+              sink.detail(node, "label_family", message.label_family)
+              flags(message).each do |role, on|
+                sink.detail(node, role, "true") if on
+              end
+              sink.detail(node, "colour", style.colour)
+            end
+
+            def flags(message)
+              style = message.style
+              { "parallel" => message.parallel?,
+                "number_plain" => message.number && !message.number.bold,
+                "dashed" => style.dashed,
+                "leftward" => style.leftward,
+                "hidden" => style.hidden,
+                "head_circle" => style.head.circle,
+                "tail_circle" => style.tail.circle }
+            end
+
+            def markers(style)
+              IR::PropertySet.new(source_marker: style.tail.glyph&.to_s,
+                                  target_marker: style.head.glyph&.to_s)
+            end
+
+            # A participant's node, or a new node for the missing end.
+            def end_node(place, message_node, sink, ids)
+              return ids.fetch(place) unless place.is_a?(Edge)
+
+              node = sink.node("open_end", nil, parent: message_node)
+              sink.detail(node, "side", place.side)
+              sink.detail(node, "local", "true") if place.local?
+              node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_adapter/participants.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRAdapter
+          # Encodes the lifelines and the boxes round neighbouring ones.
+          module Participants
+            module_function
+
+            # @return [Hash{String => IR::Node}] participant node by id
+            def call(diagram, sink)
+              ids = diagram.participants.to_h do |participant|
+                [participant.id, participant(participant, sink)]
+              end
+              diagram.boxes.each { |box| box(box, sink, ids) }
+              ids
+            end
+
+            def participant(participant, sink)
+              node = sink.node(participant.kind.to_s, participant.label)
+              sink.detail(node, "name", participant.id)
+              sink.detail(node, "stereotype", participant.stereotype)
+              Fills.call(node, participant.fill, sink)
+              node
+            end
+
+            def box(box, sink, ids)
+              node = sink.node("box", box.title)
+              Fills.call(node, box.fill, sink)
+              box.members.each do |member|
+                sink.edge("box_member", node, ids.fetch(member),
+                          parent_id: node.id)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_adapter/settings.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRAdapter
+          # Encodes what applies to the whole diagram: the footbox, the
+          # appearance skinparam and `<style>` set, the banners and the title.
+          module Settings
+            KEYS = %i[min_width alignment tab_fill tab_colour tab_size
+                      max_message arrow_width].freeze
+            HEAD_KEYS = %i[colour size style family weight line].freeze
+            private_constant :KEYS, :HEAD_KEYS
+
+            module_function
+
+            def call(diagram, sink)
+              sink.node("no_footbox") unless diagram.footbox?
+              sink.node("teoz") if diagram.teoz?
+              appearance(diagram.appearance, sink)
+              diagram.warnings.each { |line| sink.node("warning", line) }
+              sink.node("title", diagram.title) if diagram.title
+              chrome(diagram.chrome, sink)
+            end
+
+            def chrome(chrome, sink)
+              chrome.to_h.each { |kind, text| sink.node(kind.to_s, text) }
+              sink.node("legend_place", chrome.legend_place)
+            end
+
+            def appearance(appearance, sink)
+              node = sink.node("appearance")
+              KEYS.each do |key|
+                sink.detail(node, key.to_s, appearance.public_send(key))
+              end
+              paint_details(appearance, node, sink)
+              head = appearance.head_style
+              HEAD_KEYS.each do |key|
+                sink.detail(node, "head_#{key}", head.public_send(key))
+              end
+            end
+
+            def paint_details(appearance, node, sink)
+              appearance.paint.each do |role, colour|
+                sink.detail(node, "paint_#{role}", colour)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_adapter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../../../ir"
+require_relative "../ir_adapter/sink"
+require_relative "ir_adapter/fills"
+require_relative "ir_adapter/participants"
+require_relative "ir_adapter/settings"
+require_relative "ir_adapter/messages"
+require_relative "ir_adapter/blocks"
+require_relative "ir_adapter/items"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # Maps the private sequence Diagram to a notation-neutral IR::Graph:
+        # participants and boxes first, then one node per item in source
+        # order. A message is a node plus an edge between its participant
+        # nodes, and every other fact is a child node. {IRReader} is the
+        # inverse; layout still owns measuring and placing.
+        module IRAdapter
+          module_function
+
+          # @param diagram [Diagram] a parsed sequence diagram
+          # @return [IR::Graph]
+          def call(diagram)
+            sink = PlantUML::IRAdapter::Sink.new
+            ids = Participants.call(diagram, sink)
+            Settings.call(diagram, sink)
+            Items.call(diagram, sink, ids)
+            IR::Graph.new(id: "sequence_diagram", role: "sequence_diagram",
+                          nodes: sink.nodes, edges: sink.edges)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_reader/blocks.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../activation"
+require_relative "../create"
+require_relative "../destroy"
+require_relative "../delay"
+require_relative "../spacing"
+require_relative "../divider"
+require_relative "../fragment"
+require_relative "../note"
+require_relative "../page_break"
+require_relative "../ref"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRReader
+          # Rebuilds every item that is not a message.
+          module Blocks
+            module_function
+
+            def note(node, index)
+              Note.new(shape: index.detail(node, "shape").to_sym,
+                       side: index.detail(node, "side").to_sym,
+                       targets: index.target_names(node), text: node.label,
+                       parallel: !index.detail(node, "parallel").nil?,
+                       fill: Fills.call(node, index))
+            end
+
+            def ref(node, index)
+              Ref.new(targets: index.target_names(node), label: node.label)
+            end
+
+            def fragment(node, index)
+              Fragment.new(phase: index.detail(node, "phase").to_sym,
+                           keyword: index.detail(node, "keyword"),
+                           label: node.label,
+                           parallel: !index.detail(node, "parallel").nil?)
+            end
+
+            def divider(node, _index)
+              Divider.new(label: node.label)
+            end
+
+            def delay(node, _index)
+              Delay.new(label: node.label.to_s)
+            end
+
+            def spacing(node, index)
+              height = index.detail(node, "height")
+              Spacing.new(height: height&.to_f)
+            end
+
+            def activation(node, index)
+              Activation.new(participant: index.target_names(node).first,
+                             phase: index.detail(node, "phase").to_sym,
+                             color: index.detail(node, "colour"))
+            end
+
+            def destroy(node, index)
+              Destroy.new(participant: index.target_names(node).first)
+            end
+
+            def create(node, index)
+              Create.new(participant: index.target_names(node).first)
+            end
+
+            def page_break(_node, _index)
+              PageBreak.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_reader/fills.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../fill"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRReader
+          # Rebuilds the colour written after a participant or a note.
+          module Fills
+            module_function
+
+            # @return [Fill, nil]
+            def call(node, index)
+              colour = index.detail(node, "fill_colour")
+              return unless colour
+
+              opacity = index.detail(node, "fill_opacity")
+              Fill.new(colour, opacity && (opacity.to_f * 255).round)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/sequence/ir_reader/index.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../ir_reader/index"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        module IRReader
+          # The shared node lookup, plus the edges that belong to one item.
+          class Index < PlantUML::IRReader::Index
+            def initialize(graph)
+              super
+              @owned = graph.edges.group_by(&:parent_id)
+            end
+
+            # @return [Array<IR::Edge>] the edges `node` owns, in graph order
+            def edges_of(node)
+              @owned.fetch(node.id, [])
+            end
+
+            # @return [Array<String>] the participant ids `node` points at
+            def target_names(node)
+              edges_of(node).map { |edge| name(edge.target_id) }
+            end
+
+            # @return [String] the id a message names for a participant node
+            def name(node_id)
+              detail(node(node_id), "name")
+            end
+          end
+        end
+      end
+    end
+  end
+end