etassia 0.1.0

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "arrow_style"
+require_relative "edge"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # One arrow, normalised so `from` is always the sender: `B <- A` and
+        # `A -> B` read the same. `style` is an {ArrowStyle}. `label` is the
+        # source text. `from` or `to` is an {Edge} when the message has no
+        # participant at that end. `number` is the `autonumber` {Number}, or
+        # nil.
+        class Message
+          Label = Struct.new(:content, :font_family, keyword_init: true)
+
+          # The text `autonumber` draws before a label, and whether it is bold.
+          Number = Struct.new(:text, :bold, keyword_init: true) do
+            def to_s
+              text
+            end
+          end
+
+          attr_reader :from, :to, :label, :style, :number, :label_family
+
+          def initialize(from:, to:, label:, style:, number: nil)
+            @from = from
+            @to = to
+            @label = label.is_a?(Label) ? label.content : label
+            @label_family = label.is_a?(Label) ? label.font_family : nil
+            @style = style
+            @number = number_of(number)
+            freeze
+          end
+
+          # @return [Message] the same message, drawn with `number`
+          def numbered(text, bold: true)
+            display = Label.new(content: label, font_family: label_family)
+            self.class.new(from: from, to: to, label: display, style: style,
+                           number: text && Number.new(text: text, bold: bold))
+          end
+
+          # @return [String, nil] the weight of the number
+          def number_weight
+            "bold" if number&.bold
+          end
+
+          def head
+            style.head.glyph
+          end
+
+          def dashed
+            style.dashed
+          end
+
+          # Written `<-`: a message to its own sender loops out on the left.
+          def leftward?
+            style.leftward
+          end
+
+          # True for a message written after `&`; see {ParallelMessage}.
+          def parallel?
+            false
+          end
+
+          def self_message?
+            from == to
+          end
+
+          # @return [Edge, nil] the end with no participant
+          def edge
+            [from, to].grep(Edge).first
+          end
+
+          # @return [Array<String>] the participants the message touches
+          def participants
+            [from, to].grep_v(Edge)
+          end
+
+          # What is drawn at the {#edge} end.
+          def edge_end
+            from.is_a?(Edge) ? style.tail : style.head
+          end
+
+          private
+
+          def number_of(number)
+            return number if number.nil? || number.is_a?(Number)
+
+            Number.new(text: number.to_s, bold: true)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # Splits explicit message lines and wraps each to `Maxmessagesize`.
+        # Words fill a line until the next one would pass the limit; a word
+        # wider than the limit keeps a line.
+        class MessageWrap
+          # @param limit [Numeric, nil] widest line, in pixels; nil never wraps
+          # @param measure [#call] text width in pixels
+          def initialize(limit, measure)
+            @limit = limit
+            @measure = measure
+          end
+
+          # @return [Array<String>] the lines of `label`
+          def lines(label)
+            explicit_lines(label).flat_map { |line| wrapped_line(line) }
+          end
+
+          # @return [Float] the width of the widest line of `label`
+          def width(label)
+            lines(label).map { |line| @measure.call(line) }.max.to_f
+          end
+
+          private
+
+          def explicit_lines(label)
+            decoded = decode_line_breaks(label)
+            decoded = decode_quote_escapes(decoded) if doubled_quotes?(label)
+            if !decoded.include?("\n") && doubled_quotes?(decoded)
+              decoded = decoded[2...-2].strip
+            end
+            decoded.empty? ? [""] : decoded.split(/\r\n|\r|\n/, -1)
+          end
+
+          def decode_line_breaks(label)
+            label.gsub(/(\\+)n/) do
+              slashes = Regexp.last_match(1).size
+              ("\\" * (slashes / 2)) + (slashes.odd? ? "\n" : "n")
+            end
+          end
+
+          def decode_quote_escapes(label)
+            label.gsub(/\\+(?![\\n])/) do |slashes|
+              "\\" * ((slashes.size + 1) / 2)
+            end
+          end
+
+          def doubled_quotes?(label)
+            label.start_with?('""') && label.end_with?('""')
+          end
+
+          def wrapped_line(line)
+            return [line] unless @limit
+
+            words = line.split(/[ \t]+/)
+            return [""] if words.empty?
+
+            words.each_with_object([]) { |word, lines| add(lines, word) }
+          end
+
+          def add(lines, word)
+            joined = "#{lines.last} #{word}"
+            if lines.empty? || @measure.call(joined) > @limit
+              lines << word
+            else
+              lines[-1] = joined
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "embedded"
+require_relative "keyword_defaults"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # A `note`, `hnote` or `rnote`. `side` is :left, :right, :over or
+        # :across. `targets` are participant ids; empty for :across and for a
+        # left/right note that hangs off the message before it. `parallel` is
+        # true when the note began with `&`. `fill` is a {Fill}, or nil for
+        # the default note colour. `picture` is the laid-out embedded diagram.
+        class Note
+          EXTRAS = { parallel: false, fill: nil, picture: nil }.freeze
+          private_constant :EXTRAS
+
+          attr_reader :shape, :side, :targets, :text, :fill, :picture
+
+          def initialize(shape:, side:, targets:, text:, **extras)
+            extras = KeywordDefaults.resolve(extras, EXTRAS)
+            @shape = shape
+            @side = side
+            @targets = targets.freeze
+            @text = text
+            @parallel = extras[:parallel]
+            @fill = extras[:fill]
+            @picture = extras[:picture]
+            freeze
+          end
+
+          def parallel?
+            @parallel
+          end
+
+          # PlantUML also reads the two characters `\n` as a line break.
+          def lines
+            text.split(/\\n|\n/, -1)
+          end
+
+          # @return [Embedded, nil] the diagram this note holds
+          def embedded
+            Embedded.read(text)
+          end
+
+          # @param picture [Picture] the embedded diagram, laid out
+          # @return [Note] this note with its picture
+          def with_picture(picture)
+            Note.new(shape: shape, side: side, targets: targets, text: text,
+                     parallel: parallel?, fill: fill, picture: picture)
+          end
+
+          def attached?
+            targets.empty? && %i[left right].include?(side)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "fill"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # The colour written after `note right`: a hex colour in the forms
+        # {Fill} reads, or one of the names below, which PlantUML draws as
+        # these hex values. Any other name is not read.
+        module NoteFill
+          extend self
+
+          NAMES = {
+            "red" => "#FF0000", "blue" => "#0000FF", "green" => "#008000",
+            "yellow" => "#FFFF00", "orange" => "#FFA500",
+            "pink" => "#FFC0CB", "lightblue" => "#ADD8E6",
+            "lightgreen" => "#90EE90", "lightgray" => "#D3D3D3",
+            "white" => "#FFFFFF", "black" => "#000000", "gray" => "#808080",
+            "cyan" => "#00FFFF", "magenta" => "#FF00FF",
+            "purple" => "#800080", "aqua" => "#00FFFF"
+          }.freeze
+
+          # @param token [String] such as `#red` or `#ff8800`
+          # @return [Fill, nil] nil when the token is not one of the forms
+          def read(token)
+            hex = NAMES[token.to_s.delete_prefix("#").downcase]
+            hex ? Fill.new(hex) : Fill.read(token)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "../creole"
+require_relative "../drawing"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # Size and horizontal place of a note, shared by the layout (which
+        # widens gaps for it) and the walker (which draws it).
+        module NoteGeometry
+          extend self
+
+          PAD = 8.0
+          SKIN_FONT_SIZE = 13.0
+          OFFSET = 6.0
+          OVER_MARGIN = 10.0
+          BLOCK_GAP = 5.0
+          PICTURE_CHROME = 15.0
+          LINE_LEADING = 1.1776
+          # PlantUML 1.2026.6 sizes a note box as 10 + 15 per line, though
+          # the text inside steps by the font's own leading.
+          LINE_PITCH = 15.0
+          CHROME = 10.0
+          FIRST_BASELINE = 17.568
+          private_constant :LINE_PITCH, :CHROME
+
+          # Width the text needs, without regard to the participants.
+          def natural_width(note, font_size)
+            return picture_width(note.picture) + (2 * PAD) if note.picture
+
+            widest = note.lines.map { |line| line_width(line, font_size) }
+            widest.max + (2 * PAD)
+          end
+
+          # A line is as wide as it is drawn, in the face the other sequence
+          # text is measured in: creole markers and tags take no room, a bold
+          # run is measured bold, a `<size:N>` run at its own size, and a
+          # monospace run (`""..""`, an undecoded image) in the mono face.
+          def line_width(line, font_size, bold: false)
+            Creole.parse(line).sum { |run| run_width(run, font_size, bold) }
+          end
+
+          # The widest line of a multi-line label (a newline or a literal
+          # backslash-n splits it), each line measured as drawn.
+          def widest_line(text, font_size, bold: false)
+            lines = text.to_s.split(/\\n|\n/, -1)
+            lines.map { |l| line_width(l, font_size, bold: bold) }.max.to_f
+          end
+
+          def line_height(font_size)
+            font_size * LINE_LEADING
+          end
+
+          def height(note)
+            return picture_height(note.picture) + 14 if note.picture
+
+            (note.lines.size * LINE_PITCH) + CHROME
+          end
+
+          def picture_inset(picture)
+            nested = picture.scene.notes.any?(&:picture)
+            nested ? PICTURE_CHROME * picture.scale : 0.0
+          end
+
+          def picture_width(picture)
+            picture.width - (2 * picture_inset(picture))
+          end
+
+          def picture_height(picture)
+            picture.height - (2 * picture_inset(picture))
+          end
+
+          # @return [Array<Integer>] first and last participant index the
+          #   note refers to
+          def span(note, previous, ids)
+            return [0, ids.size - 1] if note.side == :across
+            return message_span(previous, ids) if note.attached?
+
+            note.targets.map { |id| ids.index(id) }.minmax
+          end
+
+          # Where a note on a closed block goes: right of the block, whichever
+          # side the source names, level with its top. `block` is the
+          # {FragmentShape}.
+          #
+          # @return [Array<Float>] left edge and width
+          def beside(block, natural)
+            [block.x + block.width + BLOCK_GAP, natural]
+          end
+
+          # @return [Array<Float>] left edge and width
+          def box(note, centers, natural)
+            low, high = centers
+            case note.side
+            when :left then [low - OFFSET - natural, natural]
+            when :right then [high + OFFSET, natural]
+            else
+              width = [natural, high - low + (2 * OVER_MARGIN)].max
+              [((low + high) / 2) - (width / 2), width]
+            end
+          end
+
+          private
+
+          def run_width(run, font_size, bold)
+            size = run.style[:size].to_f
+            size = font_size unless size.positive?
+            if run.style[:mono]
+              return TextMeasurement.measure_mono(run.text,
+                                                  font_size: size)[:width]
+            end
+
+            Drawing::Face.width(run.text, size: size,
+                                          bold: bold || run.style[:bold])
+          end
+
+          def message_span(message, ids)
+            message.participants.map { |id| ids.index(id) }.minmax
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # SVG path data for the three note shapes: a folded corner for
+        # `note`, a hexagon for `hnote` and a plain rectangle for `rnote`.
+        module NoteShape
+          extend self
+
+          FOLD = 10.0
+
+          def outline(shape, left, top, width, height)
+            right = left + width
+            bottom = top + height
+            points = case shape
+                     when :hnote then hexagon(left, top, right, bottom)
+                     when :rnote then [[left, top], [right, top],
+                                       [right, bottom], [left, bottom]]
+                     else folded(left, top, right, bottom)
+                     end
+            "M #{points.map { |x, y| "#{x} #{y}" }.join(' L ')} Z"
+          end
+
+          # @return [String, nil] the crease of a folded corner
+          def fold(shape, left, top, width)
+            return unless shape == :note
+
+            right = left + width
+            "M #{right - FOLD} #{top} L #{right - FOLD} #{top + FOLD} " \
+              "L #{right} #{top + FOLD}"
+          end
+
+          private
+
+          def folded(left, top, right, bottom)
+            [[left, top], [right - FOLD, top], [right, top + FOLD],
+             [right, bottom], [left, bottom]]
+          end
+
+          def hexagon(left, top, right, bottom)
+            middle = (top + bottom) / 2
+            [[left + FOLD, top], [right - FOLD, top], [right, middle],
+             [right - FOLD, bottom], [left + FOLD, bottom], [left, middle]]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "scene"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # The label of a message under `autonumber`: its number in bold,
+        # then the label, four pixels on. The pair is placed as one unit
+        # where the plain label would have been.
+        class NumberedLabel
+          GAP = 4.0
+
+          # @param measure [#call] text width in pixels
+          def initialize(measure, size: nil, family: nil)
+            @measure = measure
+            @size = size
+            @family = family
+          end
+
+          # @return [Float] the width the number adds to the label
+          def extra(message)
+            return 0.0 unless message.number
+
+            @measure.call(message.number.to_s) + GAP
+          end
+
+          # @param anchor [String] where the unit sits at `at_x`: "start",
+          #   "middle" or "end"
+          # @return [Array<Scene::Text>] the number, then the label
+          def texts(message, at_x, at_y, anchor)
+            left = left_of(message, at_x, anchor)
+            [piece(message.number.to_s, left, at_y, "message_number",
+                   message.number_weight),
+             piece(message.label, left + extra(message), at_y, "message_label")]
+          end
+
+          private
+
+          def left_of(message, at_x, anchor)
+            total = extra(message) + @measure.call(message.label)
+            { "middle" => at_x - (total / 2), "end" => at_x - total }
+              .fetch(anchor, at_x)
+          end
+
+          def piece(content, at_x, at_y, role, weight = nil)
+            PlantUML::Scene::Text.new(content: content, x: at_x, y: at_y,
+                                      role: role, anchor: "start",
+                                      weight: weight, size: @size,
+                                      family: @family)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # What an `autonumber` line sets: the first number, the step between
+        # numbers and the format. A format is literal text around one run of
+        # zeros, which pads the number to that width; a leading `<b>` makes it
+        # bold. Without a format the number is bold and unpadded.
+        class Numbering
+          FORMAT = /\A(?<bold><b>)?(?<before>[^0<>#.]*)(?<zeros>0+)
+                    (?<after>[^0<>#.]*)\z/x
+          private_constant :FORMAT
+
+          attr_reader :start, :step
+
+          # @param format [String, nil] the text between the quotes
+          # @return [Numbering, nil] nil when the format is not one read
+          def self.read(start: 1, step: 1, format: nil)
+            return new(start, step) unless format
+
+            parts = FORMAT.match(format) or return
+            new(start, step, parts)
+          end
+
+          def initialize(start, step, parts = nil)
+            @start = start
+            @step = step
+            @parts = parts
+            freeze
+          end
+
+          def bold?
+            @parts.nil? || !@parts[:bold].nil?
+          end
+
+          # @return [String] the text drawn for the `count`th number
+          def text(count)
+            return count.to_s unless @parts
+
+            digits = count.to_s.rjust(@parts[:zeros].length, "0")
+            "#{@parts[:before]}#{digits}#{@parts[:after]}"
+          end
+        end
+      end
+    end
+  end
+end