etassia 0.1.0

data/lib/etassia/layout/mindmap_node_size.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "../text_measurement"
+require_relative "../text_measurement/trebuchet_kerning"
+
+module Etassia
+  module Layout
+    # The box mmdc draws around a mindmap label. mmdc measures the label at
+    # 16px, wraps it at 200px, stacks lines at 1.5 times their size, and
+    # pads that text box per shape. Mindmaps draw in Trebuchet MS, so their
+    # browser widths use the generated Trebuchet advance table. Hexagon, bang
+    # and cloud sizes are linear fits to the mmdc references, not mmdc's own
+    # rule.
+    class MindmapNodeSize
+      FONT_SIZE = 16
+      LINE_HEIGHT = 24
+      LINE_HEIGHT_RATIO = LINE_HEIGHT.fdiv(FONT_SIZE)
+      MAX_TEXT_WIDTH = 200
+      BREAK = %r{<br\s*/?>|\r?\n}i
+      EMPIRICAL_WIDTH_SHAPES = %w[bang cloud].freeze
+
+      # Each entry maps the text box (width, height) to the node box.
+      SHAPES = {
+        "default" => ->(wide, high) { [wide + 40, high + 10] },
+        "square" => ->(wide, high) { [wide + 40, high + 20] },
+        "round" => ->(wide, high) { [wide + 30, high + 30] },
+        "circle" => lambda { |wide, high|
+          [[wide, high].max + 20] * 2
+        },
+        "hexagon" => ->(wide, high) { [wide + 68, high + 20] },
+        "bang" => ->(wide, high) { [(wide * 1.25) + 62.4, high + 56] },
+        "cloud" => lambda { |wide, _high|
+          [(wide * 0.74) + 48.5, (wide * 0.49) + 38.3]
+        },
+      }.freeze
+
+      # @param label [String] node label, possibly with line breaks
+      # @param shape [String] mindmap node shape
+      # @return [Hash] :width, :height and the wrapped :lines
+      def self.call(label, shape, font_size: FONT_SIZE,
+                    line_height: LINE_HEIGHT_RATIO)
+        new(label, font_size, line_height).call(shape)
+      end
+
+      def initialize(label, font_size, line_height)
+        @font_size = font_size
+        @line_height = line_height
+        @lines = label.to_s.split(BREAK).map(&:strip).reject(&:empty?)
+        @lines = [""] if @lines.empty?
+      end
+
+      def call(shape)
+        wide, high = dimensions(shape)
+        { width: wide.to_f, height: high.to_f, lines: wrapped(shape) }
+      end
+
+      private
+
+      def wrapped(shape)
+        @wrapped ||= {}
+        @wrapped[shape] ||= @lines.flat_map { |line| wrap(line, shape) }
+      end
+
+      def dimensions(shape)
+        return circle_dimensions(shape) if shape.to_s == "circle"
+
+        SHAPES.fetch(shape.to_s, SHAPES["default"])
+          .call(text_width(shape), text_height(shape))
+      end
+
+      def circle_dimensions(shape)
+        two_lines = @font_size * @line_height * 2
+        side = if text_width(shape) > two_lines
+                 text_width(shape)
+               else
+                 text_height(shape).clamp(text_width(shape), two_lines)
+               end
+        [side + 20, side + 20]
+      end
+
+      def wrap(line, shape)
+        return [line] if measure(line, shape) <= wrap_width(shape)
+
+        line.split.each_with_object([]) do |word, rows|
+          add_word(rows, word, shape)
+        end
+      end
+
+      def add_word(rows, word, shape)
+        joined = "#{rows.last} #{word}"
+        if rows.any? && measure(joined, shape) <= wrap_width(shape)
+          rows[-1] = joined
+        else
+          rows << word
+        end
+      end
+
+      def text_width(shape)
+        widest = wrapped(shape).map { |line| measure(line, shape) }.max
+        return widest unless wrapped(shape).length > @lines.length
+
+        [widest, MAX_TEXT_WIDTH].max
+      end
+
+      def wrap_width(shape)
+        @wrap_width ||= {}
+        @wrap_width[shape] ||= [MAX_TEXT_WIDTH, widest_word(shape)].max
+      end
+
+      def widest_word(shape)
+        @lines.flat_map(&:split).map { |word| measure(word, shape) }.max.to_f
+      end
+
+      def text_height(shape)
+        wrapped(shape).length * @font_size * @line_height
+      end
+
+      def measure(text, shape)
+        width = TextMeasurement.measure_in(
+          :trebuchet, text, font_size: @font_size
+        )[:width]
+        return width if EMPIRICAL_WIDTH_SHAPES.include?(shape.to_s)
+
+        width + TextMeasurement::TrebuchetKerning.adjustment(
+          text, font_size: @font_size
+        )
+      end
+    end
+  end
+end

data/lib/etassia/layout/packet.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../notation/mermaid/ir_adapters/packet"
+
+module Etassia
+  module Layout
+    # Transforms a Packet into a positioned layout structure.
+    #
+    # Geometry follows mermaid's packet renderer: one 32-bit word per row,
+    # each bit 32px wide, each block 32px high with a 5px right gap, the
+    # start and end bit numbers drawn just above the block, and the title
+    # centred in the last row slot.
+    #
+    # @example Transform a packet diagram
+    #   transform = Layout::Packet.new
+    #   layout = transform.to_graph(diagram)
+    class Packet < Base
+      BITS_PER_ROW = 32
+      BIT_WIDTH = 32
+      ROW_HEIGHT = 32
+      PADDING_X = 5
+      # mermaid's paddingY (5) plus 10 for the bit numbers drawn above a row.
+      PADDING_Y = 15
+      ROW_PITCH = ROW_HEIGHT + PADDING_Y
+
+      class Box < Lutaml::Model::Serializable
+        attribute :x, :float
+        attribute :y, :float
+        attribute :width, :float
+        attribute :height, :float
+      end
+
+      class Label < Lutaml::Model::Serializable
+        attribute :text, :string
+        attribute :x, :float
+        attribute :y, :float
+        attribute :font_size, :float
+        attribute :text_anchor, :string
+        attribute :dominant_baseline, :string
+        attribute :style, :string
+      end
+
+      class Field < Lutaml::Model::Serializable
+        attribute :box, Box
+        attribute :label, Label
+        attribute :start_label, Label
+        attribute :end_label, Label
+      end
+
+      class Scene < Layout::Scene
+        attribute :view_box, :string
+        attribute :title, Label
+        attribute :fields, Field, collection: true, default: -> { [] }
+      end
+
+      # Transforms the diagram into a layout structure.
+      #
+      # @param diagram [Diagram::Packet] the packet diagram
+      # @return [Hash] layout data with field segments and canvas size
+      def build_graph(diagram)
+        document = ir_document(diagram)
+        fields = document.items.select { |item| item.role == "field" }
+        row_count = fields.empty? ? 0 : packet_row_count(fields)
+        size = canvas_size(row_count, document.label)
+        { fields: position_fields(fields), row_count: row_count,
+          title: document.label, width: size.first, height: size.last }
+      end
+
+      private
+
+      def scene(diagram)
+        scene_from_graph(build_graph(diagram))
+      end
+
+      def ir_document(diagram)
+        return diagram if diagram.is_a?(IR::Prepositioned)
+
+        Notation::Mermaid::IRAdapters::Packet.call(diagram)
+      end
+
+      def scene_from_graph(graph)
+        width, height = canvas_size(graph.fetch(:row_count), graph[:title])
+        Scene.new(
+          width: width, height: height, view_box: "0 0 #{width} #{height}",
+          title: title_label(graph[:title], width, height),
+          fields: graph.fetch(:fields).map { |field| typed_field(field) }
+        )
+      end
+
+      # mermaid: (rows + 1) row slots, minus one row height without a title.
+      def canvas_size(row_count, title)
+        height = (ROW_PITCH * (row_count + 1)) - (title ? 0 : ROW_HEIGHT)
+        [(BITS_PER_ROW * BIT_WIDTH) + 2, height]
+      end
+
+      def title_label(title, width, height)
+        return unless title
+
+        Label.new(
+          text: title, x: width / 2.0, y: height - (ROW_PITCH / 2.0),
+          font_size: normal_font_size, text_anchor: "middle",
+          dominant_baseline: "middle", style: "title"
+        )
+      end
+
+      def typed_field(field)
+        first = field.fetch(:bit_start)
+        last = field.fetch(:bit_end)
+        box = block_box(first, last)
+        Field.new(
+          box: box, label: block_label(field[:label], box),
+          start_label: start_label(first, last, box),
+          end_label: end_label(first, last, box)
+        )
+      end
+
+      def block_box(first, last)
+        Box.new(
+          x: ((first % BITS_PER_ROW) * BIT_WIDTH) + 1,
+          y: ((first / BITS_PER_ROW) * ROW_PITCH) + PADDING_Y,
+          width: ((last - first + 1) * BIT_WIDTH) - PADDING_X,
+          height: ROW_HEIGHT,
+        )
+      end
+
+      def block_label(text, box)
+        Label.new(
+          text: text, x: box.x + (box.width / 2.0),
+          y: box.y + (ROW_HEIGHT / 2.0), font_size: small_font_size,
+          text_anchor: "middle", dominant_baseline: "middle", style: "field"
+        )
+      end
+
+      def start_label(first, last, box)
+        single = first == last
+        Label.new(
+          text: first.to_s, x: box.x + (single ? box.width / 2.0 : 0),
+          y: box.y - 2, font_size: bit_font_size,
+          text_anchor: single ? "middle" : "start",
+          dominant_baseline: "auto", style: "start"
+        )
+      end
+
+      def end_label(first, last, box)
+        return if first == last
+
+        Label.new(
+          text: last.to_s, x: box.x + box.width, y: box.y - 2,
+          font_size: bit_font_size, text_anchor: "end",
+          dominant_baseline: "auto", style: "end"
+        )
+      end
+
+      def normal_font_size
+        theme.typography&.font_size_normal || 14
+      end
+
+      def small_font_size
+        theme.typography&.font_size_small || 12
+      end
+
+      # Packet bit numbers sit one typography step below field labels.
+      def bit_font_size
+        small_font_size - (normal_font_size - small_font_size)
+      end
+
+      def packet_row_count(fields)
+        maximum = fields.map { |field| bit_end(field) }.max
+        ((maximum + 1).to_f / BITS_PER_ROW).ceil
+      end
+
+      # Positions all fields in the grid.
+      #
+      # @param fields [Array<Diagram::PacketField>] fields to position
+      # @return [Array<Hash>] positioned fields with coordinates
+      def position_fields(fields)
+        fields.flat_map do |field|
+          if start_row(field) == end_row(field)
+            [position_single_field(field)]
+          else
+            split_field_across_rows(field)
+          end
+        end
+      end
+
+      # Positions a field that fits in a single row.
+      #
+      # @param field [Diagram::PacketField] field to position
+      # @return [Hash] positioned field data
+      def position_single_field(field)
+        row = start_row(field)
+        start_col = start_bit_in_row(field)
+        end_col = end_bit_in_row(field)
+        field_segment(
+          field, bit_start(field)..bit_end(field), [row, start_col, end_col]
+        )
+      end
+
+      def field_segment(field, bit_range, placement)
+        row, start_col, end_col = placement
+        {
+          label: field.label,
+          bit_start: bit_range.begin,
+          bit_end: bit_range.end,
+        }.merge(segment_geometry(row, start_col, end_col))
+      end
+
+      def segment_geometry(row, start_col, end_col)
+        { row: row, start_col: start_col, end_col: end_col }
+      end
+
+      # Splits a field that spans multiple rows into visual segments.
+      #
+      # @param field [Diagram::PacketField] field to split
+      # @return [Array<Hash>] array of positioned segments
+      def split_field_across_rows(field)
+        segments = []
+        current_bit = bit_start(field)
+        final_bit = bit_end(field)
+
+        while current_bit <= final_bit
+          segment = split_segment(field, current_bit, final_bit)
+          segments << segment
+          segment_end_bit = segment[:bit_end]
+          current_bit = segment_end_bit + 1
+        end
+
+        segments
+      end
+
+      def split_segment(field, current_bit, final_bit)
+        row = current_bit / BITS_PER_ROW
+        start_col = current_bit % BITS_PER_ROW
+        segment_end_bit = segment_end(row, final_bit)
+        segment = field_segment(
+          field, current_bit..segment_end_bit,
+          [row, start_col, segment_end_bit % BITS_PER_ROW]
+        )
+        segment.merge(
+          segment_status(field, current_bit, segment_end_bit, final_bit),
+        )
+      end
+
+      def segment_end(row, final_bit)
+        [final_bit, ((row + 1) * BITS_PER_ROW) - 1].min
+      end
+
+      def segment_status(field, current_bit, segment_end_bit, final_bit)
+        {
+          is_continuation: current_bit > bit_start(field),
+          is_final: segment_end_bit == final_bit,
+        }
+      end
+
+      def bit_placement(field)
+        field.placements.find { |placement| placement.dimension == "bit" }
+      end
+
+      def bit_start(field)
+        bit_placement(field).value.value.to_i
+      end
+
+      def bit_end(field)
+        bit_start(field) + bit_placement(field).span.value.to_i - 1
+      end
+
+      def start_row(field)
+        bit_start(field) / BITS_PER_ROW
+      end
+
+      def end_row(field)
+        bit_end(field) / BITS_PER_ROW
+      end
+
+      def start_bit_in_row(field)
+        bit_start(field) % BITS_PER_ROW
+      end
+
+      def end_bit_in_row(field)
+        bit_end(field) % BITS_PER_ROW
+      end
+    end
+  end
+end