etassia 0.1.0

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative "activation"
+require_relative "arrow_style"
+require_relative "create"
+require_relative "delay"
+require_relative "destroy"
+require_relative "divider"
+require_relative "fragment"
+require_relative "message"
+require_relative "numbering"
+require_relative "page_break"
+require_relative "spacing"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # Collects the items of a diagram in source order and answers the
+        # structural questions that need history: which call a `return`
+        # answers, which block an `else` or `end` belongs to. Each query
+        # returns false instead of adding an item it cannot place.
+        class Outline
+          def initialize
+            @items = []
+            @calls = []
+            @blocks = []
+            @depth = Hash.new(0)
+            @number = nil
+            @counting = false
+          end
+
+          # @return [Array] the items of the first page, which ends with its
+          #   {PageBreak}; later pages are read but not kept.
+          def items
+            cut = @items.index { |item| item.is_a?(PageBreak) }
+            cut ? @items.first(cut + 1) : @items
+          end
+
+          # `marks` are the changes written on the same line, as
+          # [phase, id, color] triples; phase is :on, :off or :destroy.
+          def message(message, marks = [])
+            message = numbered(message) or return false
+            @calls << message unless message.dashed
+            @items << message
+            marks.each { |phase, id, color| mark(phase, id, color) }
+          end
+
+          # PlantUML draws nothing for a `--` or `deactivate` on a
+          # participant with no open bar, so that change is dropped.
+          # Messages after this line are numbered as `numbering` says.
+          def autonumber(numbering)
+            @numbering = numbering
+            @number = numbering.start
+            @counting = true
+          end
+
+          # `autonumber stop` and `autonumber resume`: false when no
+          # numbering was started.
+          def counting(on)
+            return false unless @numbering
+
+            @counting = on
+            self
+          end
+
+          def activation(phase, id, color = nil)
+            return true unless allowed?(phase, id)
+
+            @depth[id] += phase == :on ? 1 : -1
+            @items << Activation.new(participant: id, phase: phase,
+                                     color: color)
+          end
+
+          # false when `id` already took part in a message: PlantUML cannot
+          # create a participant that is already on the page.
+          def create(id)
+            return false if @items.any? { |item| appears?(item, id) }
+
+            @items << Create.new(participant: id)
+          end
+
+          def destroy(id)
+            @items << Destroy.new(participant: id)
+          end
+
+          def active?(id)
+            @depth[id].positive?
+          end
+
+          def allowed?(phase, id)
+            phase != :off || @depth[id].positive?
+          end
+
+          def reply(label)
+            call = @calls.pop or return false
+            return false if call.edge
+
+            style = ArrowStyle.plain(:filled, dashed: true)
+            message(Message.new(from: call.to, to: call.from, label: label,
+                                style: style))
+          end
+
+          def note(note)
+            @items << note
+          end
+
+          def ref(ref)
+            @items << ref
+          end
+
+          # Whether the last thing drawn is a message, bars opened or
+          # closed after it aside: a note still hangs off that message.
+          def after_message?
+            last = @items.reverse_each.find { |i| !i.is_a?(Activation) }
+            last.is_a?(Message)
+          end
+
+          def after_ref?
+            @items.last.is_a?(Ref)
+          end
+
+          def after_block?
+            last = @items.last
+            last.is_a?(Fragment) && last.phase == :close
+          end
+
+          # Whether a line starting with `&` has an element to share a row
+          # with: a message, a note or a block that has just closed.
+          def anchored?
+            last = @items.reverse_each.find do |item|
+              !item.is_a?(Activation) && !item.is_a?(Destroy)
+            end
+            last.is_a?(Message) || last.is_a?(Note) ||
+              (last.is_a?(Fragment) && last.phase == :close)
+          end
+
+          # False inside a block, which a page would have to cut in two.
+          def newpage
+            return false if open_block?
+
+            @items << PageBreak.new
+          end
+
+          def divider(label)
+            @items << Divider.new(label: label)
+          end
+
+          def spacing(height)
+            @items << Spacing.new(height: height)
+          end
+
+          def delay(label)
+            @items << Delay.new(label: label)
+          end
+
+          def open_block(keyword, label, parallel: false)
+            @blocks << keyword
+            @items << Fragment.new(phase: :open, keyword: keyword,
+                                   label: label, parallel: parallel)
+          end
+
+          def branch(label)
+            return false if @blocks.empty?
+
+            @items << Fragment.new(phase: :else, keyword: @blocks.last,
+                                   label: label)
+          end
+
+          def close_block
+            keyword = @blocks.pop or return false
+
+            @items << Fragment.new(phase: :close, keyword: keyword)
+          end
+
+          def open_block?
+            !@blocks.empty?
+          end
+
+          private
+
+          def appears?(item, id)
+            item.is_a?(Message) && [item.from, item.to].include?(id)
+          end
+
+          # Under `autonumber` a message takes the next number. One with no
+          # label or a line break in it is not drawn; false then.
+          def numbered(message)
+            return message unless @counting
+            return if message.label.to_s.strip.empty?
+            return if message.label.include?("\\n")
+
+            message.numbered(@numbering.text(@number), bold: @numbering.bold?)
+              .tap { @number += @numbering.step }
+          end
+
+          def mark(phase, id, color)
+            phase == :destroy ? destroy(id) : activation(phase, id, color)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # A `newpage` line. PlantUML's single-image output holds only the
+        # first page, so nothing after the first one is drawn.
+        class PageBreak
+          def initialize
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "appearance"
+require_relative "fill"
+require_relative "head_style"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # Reads the colour and thickness skinparams PlantUML 1.2026.6 honours
+        # on a sequence diagram, each probed against the JAR. A key it does
+        # not list (`LifeLineBorderColor`, without `Sequence`, is one) makes
+        # {.read} return nil, so the parser refuses the line.
+        module Paint
+          extend self
+
+          ROLES = %i[head_fill head_line arrow lifeline box_fill box_line
+                     divider_fill divider_line group_line note_fill
+                     note_line background text_message_label text_note
+                     text_box text_divider].freeze
+          PAINTED = {
+            "participantbackgroundcolor" => :head_fill,
+            "participantbordercolor" => :head_line,
+            "arrowcolor" => :arrow,
+            "sequencelifelinebordercolor" => :lifeline,
+            "sequenceboxbackgroundcolor" => :box_fill,
+            "sequenceboxbordercolor" => :box_line,
+            "sequencedividerbackgroundcolor" => :divider_fill,
+            "sequencedividerbordercolor" => :divider_line,
+            "sequencegroupbordercolor" => :group_line,
+            "notebackgroundcolor" => :note_fill,
+            "notebordercolor" => :note_line,
+            "backgroundcolor" => :background,
+            "arrowfontcolor" => :text_message_label,
+            "notefontcolor" => :text_note,
+            "sequenceboxfontcolor" => :text_box,
+            "sequencedividerfontcolor" => :text_divider,
+          }.freeze
+          APPEARANCE = {
+            "sequencegroupbackgroundcolor" => :tab_fill,
+            "sequencegroupheaderfontcolor" => :tab_colour,
+          }.freeze
+          THICKNESS = /\A(?:\d+|\d*\.\d+)\z/
+          private_constant :PAINTED, :APPEARANCE, :THICKNESS
+
+          # @param key [String] the skinparam name, in any case
+          # @param value [String] what follows it
+          # @return [Appearance, nil] nil for a key or value not read
+          def read(key, value)
+            name = key.downcase.sub(/\Asequence(?=participant|arrow)/, "")
+            return thickness(name, value) if name.end_with?("arrowthickness")
+
+            colour = Fill.read(value.start_with?("#") ? value : "##{value}")
+            return unless colour
+
+            role_setting(name, key.downcase, colour.colour)
+          end
+
+          private
+
+          def thickness(_name, value)
+            Appearance.new(arrow_width: value) if THICKNESS.match?(value)
+          end
+
+          def role_setting(name, plain, colour)
+            if PAINTED.key?(name)
+              Appearance.new(paint: { PAINTED.fetch(name) => colour })
+            elsif APPEARANCE.key?(plain)
+              Appearance.new(APPEARANCE.fetch(plain) => colour)
+            elsif name == "participantfontcolor"
+              Appearance.new(head_style: HeadStyle.new(colour: colour))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "message"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # A message written after `&`: it is drawn on the row of the item
+        # before it.
+        class ParallelMessage < Message
+          def parallel?
+            true
+          end
+        end
+      end
+    end
+  end
+end