etassia 0.1.0

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "../../../layout/scene"
+require_relative "../scene"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # Final-canvas geometry for a sequence diagram: coordinates and
+        # drawable roles only; the renderer picks colours and strokes.
+        class Scene < Etassia::Layout::Scene
+          class Head < Lutaml::Model::Serializable
+            class Rectangle < Lutaml::Model::Serializable
+              attribute :x, :float
+              attribute :y, :float
+              attribute :width, :float
+              attribute :height, :float
+              attribute :rx, :float
+              attribute :ry, :float
+            end
+
+            class Ellipse < Lutaml::Model::Serializable
+              attribute :cx, :float
+              attribute :cy, :float
+              attribute :rx, :float
+              attribute :ry, :float
+            end
+
+            class Path < Lutaml::Model::Serializable
+              attribute :data, :string
+              attribute :filled, :boolean
+            end
+
+            class Line < Lutaml::Model::Serializable
+              attribute :x1, :float
+              attribute :y1, :float
+              attribute :x2, :float
+              attribute :y2, :float
+            end
+
+            class Polygon < Lutaml::Model::Serializable
+              attribute :points, :string
+            end
+
+            attribute :id, :string
+            attribute :kind, :string
+            attribute :x, :float
+            attribute :y, :float
+            attribute :width, :float
+            attribute :height, :float
+            attribute :fill, :string
+            attribute :fill_opacity, :float
+            attribute :stroke, :string
+            attribute :texts, PlantUML::Scene::Text, collection: true
+            attribute :rectangles, Rectangle, collection: true
+            attribute :ellipses, Ellipse, collection: true
+            attribute :paths, Path, collection: true
+            attribute :lines, Line, collection: true
+            attribute :polygons, Polygon, collection: true
+          end
+
+          # One shape at an arrow end: a "polygon" (points), a "line" or a
+          # "circle". A polygon is filled with the edge colour when `filled`.
+          class Mark < Lutaml::Model::Serializable
+            attribute :kind, :string
+            attribute :filled, :boolean
+            attribute :heavy, :boolean
+            attribute :points, :string
+            attribute :x1, :float
+            attribute :y1, :float
+            attribute :x2, :float
+            attribute :y2, :float
+            attribute :cx, :float
+            attribute :cy, :float
+            attribute :r, :float
+          end
+
+          class Arrow < Lutaml::Model::Serializable
+            attribute :id, :string
+            attribute :path, :string
+            attribute :dashed, :boolean
+            attribute :colour, :string
+            attribute :marks, Mark, collection: true
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          class Frame < Lutaml::Model::Serializable
+            attribute :x, :float
+            attribute :y, :float
+            attribute :width, :float
+            attribute :height, :float
+            attribute :fill, :string
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          class Fragment < Lutaml::Model::Serializable
+            attribute :x, :float
+            attribute :y, :float
+            attribute :width, :float
+            attribute :height, :float
+            attribute :tab_path, :string
+            attribute :tab_fill, :string
+            attribute :separators, PlantUML::Scene::Segment, collection: true
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          # A laid-out diagram drawn inside a note, `scale` times larger.
+          class Picture < Lutaml::Model::Serializable
+            attribute :x, :float
+            attribute :y, :float
+            attribute :scale, :float
+            attribute :scene, Etassia::Layout::Scene
+          end
+
+          class Note < Lutaml::Model::Serializable
+            attribute :picture, Picture
+            attribute :path, :string
+            attribute :fold_path, :string
+            attribute :fill, :string
+            attribute :fill_opacity, :float
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          # A warning PlantUML draws above the heads.
+          class Banner < Lutaml::Model::Serializable
+            attribute :x, :float
+            attribute :y, :float
+            attribute :width, :float
+            attribute :height, :float
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          # The header, caption or footer, as lines of text.
+          class TextBlock < Lutaml::Model::Serializable
+            attribute :id, :string
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          # The framed legend.
+          class Legend < Lutaml::Model::Serializable
+            attribute :x, :float
+            attribute :y, :float
+            attribute :width, :float
+            attribute :height, :float
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          # The title above the diagram.
+          class Title < Lutaml::Model::Serializable
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          class Bar < Lutaml::Model::Serializable
+            attribute :fill, :string
+            attribute :x, :float
+            attribute :y, :float
+            attribute :width, :float
+            attribute :height, :float
+          end
+
+          class Divider < Lutaml::Model::Serializable
+            attribute :lines, PlantUML::Scene::Segment, collection: true
+            attribute :x, :float
+            attribute :y, :float
+            attribute :width, :float
+            attribute :height, :float
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          # A `...` gap between two messages, with its text if it has any.
+          class Delay < Lutaml::Model::Serializable
+            attribute :y1, :float
+            attribute :y2, :float
+            attribute :texts, PlantUML::Scene::Text, collection: true
+          end
+
+          # `role=value` for each colour or thickness skinparam set.
+          attribute :paint, :string, collection: true
+          attribute :banners, Banner, collection: true
+          attribute :title, Title
+          attribute :text_blocks, TextBlock, collection: true
+          attribute :legend, Legend
+          attribute :frames, Frame, collection: true
+          attribute :fragments, Fragment, collection: true
+          attribute :notes, Note, collection: true
+          attribute :dividers, Divider, collection: true
+          attribute :delays, Delay, collection: true
+          attribute :bars, Bar, collection: true
+          attribute :crosses, PlantUML::Scene::Segment, collection: true
+          attribute :page_breaks, PlantUML::Scene::Segment, collection: true
+          attribute :heads, Head, collection: true
+          attribute :lifelines, PlantUML::Scene::Segment, collection: true
+          attribute :arrows, Arrow, collection: true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # The paint PlantUML 1.2026.6 gives an unstyled sequence diagram,
+        # measured from its SVG. It stands in for the default theme only; any
+        # other theme keeps painting from its own colour roles.
+        module Skin
+          PAINT = {
+            head_fill: "#E2E2F0", line: "#181818", note_fill: "#FEFFDD",
+            bar_fill: "#FFFFFF", tab_fill: "#EEEEEE", box_fill: "#DDDDDD",
+            frame_stroke: "#000000", label_fill: "#EEEEEE"
+          }.freeze
+          WIDTH = {
+            thin: "0.5", arrow: "1", frame: "1.5", bar: "1", separator: "1"
+          }.freeze
+          SIZES = { "message_label" => "13", "note" => "13", "box" => "13",
+                    "fragment_tab" => "13", "fragment_guard" => "11",
+                    "divider" => "13", "delay" => "11" }.freeze
+          HEAD_CORNER = 2.5
+          SEPARATOR_DASH = "2,2"
+          FAMILY = "sans-serif"
+          private_constant :PAINT, :WIDTH, :SIZES, :HEAD_CORNER,
+                           :SEPARATOR_DASH, :FAMILY
+
+          private
+
+          # @return [String, nil] what a skinparam set for the role, which
+          #   wins over the skin and the theme
+          def painted(role)
+            @painted[role]
+          end
+
+          def read_painted(scene)
+            @painted = scene.paint.to_h do |pair|
+              role, value = pair.split("=", 2)
+              [role.to_sym, value]
+            end
+          end
+
+          def skinned?
+            theme.nil? || theme.name.nil? || theme.name == "default"
+          end
+
+          # @return [String, nil] the skin colour for the role, or nil when a
+          #   theme paints it
+          def skin_paint(role)
+            PAINT.fetch(role) if skinned?
+          end
+
+          def skin_width(role)
+            WIDTH.fetch(role) if skinned?
+          end
+
+          def skin_corner(shape_corner)
+            skinned? ? HEAD_CORNER : shape_corner
+          end
+
+          def skin_size(role)
+            SIZES[role] if skinned?
+          end
+
+          def skin_family
+            FAMILY if skinned?
+          end
+
+          def skin_dash(default)
+            skinned? ? SEPARATOR_DASH : default
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # A `|||` or `||N||` line: blank room between two rows. `height` is
+        # the N pixels written, or nil for the bare form, which PlantUML
+        # draws as {DEFAULT} pixels.
+        class Spacing
+          DEFAULT = 25.0
+
+          attr_reader :height
+
+          def initialize(height: nil)
+            @height = height
+            freeze
+          end
+
+          # @return [Float] the room the line adds, in pixels
+          def room
+            height || DEFAULT
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../package_color"
+require_relative "appearance"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # Reads one `<style>` block of a sequence diagram:
+        #
+        #   sequenceDiagram {
+        #     participant { MinimumWidth N  HorizontalAlignment L }
+        #     groupHeader { FontColor C  BackGroundColor C  FontSize N }
+        #   }
+        #
+        # Anything else makes {.read} return nil, so the parser refuses the
+        # block instead of ignoring part of it. The nested forms
+        # `group { header { FontColor C  BackGroundColor C } }` and the same
+        # under `reference` are read and dropped: PlantUML 1.2026.6 draws
+        # them with no effect.
+        class Style
+          TOKEN = /[{}]|[^\s{}]+/
+          PROPERTIES = {
+            %w[sequencediagram participant] =>
+              { "minimumwidth" => :min_width,
+                "horizontalalignment" => :alignment,
+                "fontcolor" => :head_colour, "fontsize" => :head_size,
+                "fontstyle" => :head_style, "fontname" => :head_family,
+                "fontweight" => :head_weight, "linecolor" => :head_line },
+            %w[sequencediagram groupheader] =>
+              { "fontcolor" => :tab_colour, "backgroundcolor" => :tab_fill,
+                "fontsize" => :tab_size },
+          }.freeze
+          NESTED = {
+            "fontcolor" => :ignored, "backgroundcolor" => :ignored
+          }.freeze
+          INERT = {
+            %w[sequencediagram group header] => NESTED,
+            %w[sequencediagram reference header] => NESTED,
+          }.freeze
+          PARENTS = [%w[sequencediagram], %w[sequencediagram group],
+                     %w[sequencediagram reference]].freeze
+          ALIGNMENTS = %w[left center right].freeze
+          WEIGHT = /\A(?:[1-9]00|bold|normal)\z/i
+          FAMILY = /\A[\w-]+\z/
+          COMMENT = %r{/\*.*?\*/}m
+          NAMED = { "lightyellow" => "#FFFFE0" }.freeze
+          HEAD_TEXT = {
+            head_style: ->(text) { text.downcase if text.casecmp?("italic") },
+            head_family: ->(text) { text if FAMILY.match?(text) },
+            head_weight: ->(text) { text.downcase if WEIGHT.match?(text) },
+          }.freeze
+          private_constant :TOKEN, :PROPERTIES, :NESTED, :INERT, :PARENTS,
+                           :ALIGNMENTS, :NAMED, :WEIGHT, :FAMILY, :COMMENT,
+                           :HEAD_TEXT
+
+          # @param text [String] what lies between `<style>` and `</style>`
+          # @return [Appearance, nil] nil when the block sets anything else
+          def self.read(text)
+            plain = text.gsub(COMMENT, " ").gsub(/(\w):(?=\s)/, "\\1")
+              .gsub(/;(?=\s|\z)/, "")
+            new(plain.scan(TOKEN)).read
+          end
+
+          def initialize(tokens)
+            @tokens = tokens
+            @path = []
+            @values = {}
+          end
+
+          def read
+            catch(:refused) do
+              step until @tokens.empty?
+              @path.empty? ? appearance : nil
+            end
+          end
+
+          private
+
+          def appearance
+            head, rest = @values.partition { |key, _| key.start_with?("head_") }
+            style = head.to_h { |k, v| [k.to_s[5..].to_sym, v] }
+            Appearance.new(**rest.to_h, head_style: HeadStyle.new(**style))
+          end
+
+          def step
+            token = @tokens.shift
+            if token == "}"
+              @path.empty? ? refuse : @path.pop
+            elsif @tokens.first == "{"
+              enter(token)
+            else
+              assign(token, @tokens.shift)
+            end
+          end
+
+          def enter(name)
+            @tokens.shift
+            @path << name.downcase
+            refuse unless known_path?
+          end
+
+          def known_path?
+            PROPERTIES.key?(@path) || INERT.key?(@path) ||
+              PARENTS.include?(@path)
+          end
+
+          def assign(name, value)
+            key = PROPERTIES.fetch(@path) { INERT.fetch(@path, {}) }
+              .fetch(name.downcase) { refuse }
+            return if key == :ignored
+
+            @values[key] = convert(key, value.to_s) or refuse
+          end
+
+          def convert(key, value)
+            return size(value) if %i[min_width tab_size head_size].include?(key)
+            return alignment(value) if key == :alignment
+
+            text_or_colour(key, value)
+          end
+
+          def size(value)
+            number = Integer(value, 10, exception: false)
+            number if number&.positive?
+          end
+
+          def text_or_colour(key, value)
+            rule = HEAD_TEXT[key]
+            rule ? rule.call(value) : colour(value)
+          end
+
+          def alignment(value)
+            value.downcase.to_sym if ALIGNMENTS.include?(value.downcase)
+          end
+
+          def colour(value)
+            return PackageColor.hex(value) if value.start_with?("#")
+
+            NAMED.fetch(value.downcase) { PackageColor::NAMED[value.downcase] }
+          end
+
+          def refuse
+            throw :refused, nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Sequence
+        # How far a fragment's keyword tab grows when `groupHeader` sets a
+        # `FontSize` other than the diagram's text size. The two rates are
+        # fitted to PlantUML 1.2026.6 at sizes 10, 20 and 30.
+        class TabSize
+          HEIGHT_PER_PX = 1.18
+          BASELINE_PER_PX = 0.97
+
+          attr_reader :size
+
+          # @param size [Numeric, nil] the `FontSize`; nil keeps `base`
+          # @param base [Numeric] the diagram's text size
+          def initialize(size, base)
+            @base = base.to_f
+            @size = (size || base).to_f
+          end
+
+          def custom?
+            size != @base
+          end
+
+          def scale
+            size / @base
+          end
+
+          def height_growth
+            ((size - @base) * HEIGHT_PER_PX).round(2)
+          end
+
+          def baseline_growth
+            ((size - @base) * BASELINE_PER_PX).round(2)
+          end
+        end
+      end
+    end
+  end
+end