etassia 0.1.0

data/lib/etassia/layout/grid.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Layout
+    # Positions a graph without a layout engine.
+    #
+    # Temporary: TODO.architecture item 06 deletes this class, once
+    # Engine no longer receives a legacy graph result to position. It has
+    # no successor and is not what elkrb replaces; delete it, do not
+    # extend it. The geometry lives here rather than in the engine so the
+    # engine stays about the pipeline.
+    #
+    # Coordinates follow the ELK convention: a child is positioned inside
+    # its parent, not on the page. Only the renderer adds the offsets up.
+    class Grid
+      COLUMNS = 3
+
+      # The page edge, and the smallest a grid cell has ever been. Keeping
+      # the floor means every diagram that fitted the old fixed grid lands
+      # on exactly the coordinates it used to.
+      MARGIN = 50
+      MIN_CELL_WIDTH = 250
+      MIN_CELL_HEIGHT = 200
+
+      # Breathing room around a cell that outgrows the floor, and inside a
+      # cluster. Approximate: matching mermaid's spacing is layout parity
+      # work, and this is the placeholder it will replace.
+      CELL_GAP = 30
+      CLUSTER_PADDING = 20
+
+      # @param graph [Hash] the graph to position in place
+      # @return [Hash] the same graph
+      def self.apply(graph)
+        new.apply(graph)
+      end
+
+      def apply(graph)
+        place(graph[:children]) if graph.is_a?(Hash) && graph[:children]
+
+        graph
+      end
+
+      private
+
+      # Clusters pack bottom-up: a box has no size until the things inside
+      # it have somewhere to sit, and its column is not wide enough until
+      # the box has a size.
+      def place(children)
+        children.each { |child| pack(child) if cluster?(child) }
+        arrange(children)
+      end
+
+      def pack(cluster)
+        contents = cluster[:children] || []
+        contents.each { |child| pack(child) if cluster?(child) }
+        arrange(contents)
+        fit_cluster(cluster, contents)
+      end
+
+      # Only the flowchart transform marks a child as a cluster. Treating
+      # every nested child as one resized the boundaries and namespaces
+      # that c4, class and er diagrams nest, which is not this change.
+      #
+      # Renderer::Flowchart#cluster? is the second copy of this.
+      def cluster?(child)
+        child.dig(:metadata, :cluster) == true
+      end
+
+      # The contents drop below the title band and sit on the padding, then
+      # the box takes whatever size that needs — but never less than the
+      # title, which would otherwise run out over the edge.
+      def fit_cluster(cluster, contents)
+        band = title_band(cluster)
+        return fit_empty_cluster(cluster, band) if contents.empty?
+
+        shift(contents,
+              CLUSTER_PADDING - low(contents, :x),
+              band - low(contents, :y))
+        fit_cluster_bounds(cluster, contents)
+      end
+
+      def fit_empty_cluster(cluster, band)
+        cluster[:width] = titled_width(cluster)
+        cluster[:height] = band + CLUSTER_PADDING
+      end
+
+      def fit_cluster_bounds(cluster, contents)
+        cluster[:width] = [high(contents, :x, :width) + CLUSTER_PADDING,
+                           titled_width(cluster)].max
+        cluster[:height] = high(contents, :y, :height) + CLUSTER_PADDING
+      end
+
+      # mermaid writes the title inside the box, along the top.
+      def title_band(cluster)
+        label_size(cluster, :height) + (CLUSTER_PADDING * 2)
+      end
+
+      def titled_width(cluster)
+        label_size(cluster, :width) + (CLUSTER_PADDING * 2)
+      end
+
+      def label_size(cluster, axis)
+        label = (cluster[:labels] || []).first
+        label ? label[axis].to_i : 0
+      end
+
+      # A cell is at least the size it has always been, so ordinary
+      # diagrams do not move. A cluster is bigger than that, and widens
+      # its own column rather than overlapping the next one.
+      def arrange(children)
+        rows = children.each_slice(COLUMNS).to_a
+        widths = column_widths(rows)
+        heights = rows.map { |row| row_height(row) }
+
+        rows.each_with_index do |row, r|
+          arrange_row(row, r, widths, heights)
+        end
+      end
+
+      def arrange_row(row, row_index, widths, heights)
+        row.each_with_index do |child, column_index|
+          next if child[:x] && child[:y]
+
+          child[:x] = MARGIN + widths.take(column_index).sum
+          child[:y] = MARGIN + heights.take(row_index).sum
+          place_nested_children(child)
+        end
+      end
+
+      def place_nested_children(child)
+        place(child[:children]) if child[:children] && !cluster?(child)
+      end
+
+      # Only a cluster may outgrow a cell. Sizing cells to ordinary nodes
+      # as well would move every diagram in the project, and that is a
+      # different change from this one.
+      def column_widths(rows)
+        Array.new(COLUMNS) do |col|
+          boxes = rows.filter_map { |row| row[col] }.select { |c| cluster?(c) }
+          [MIN_CELL_WIDTH, *boxes.map { |c| c[:width].to_i + CELL_GAP }].max
+        end
+      end
+
+      def row_height(row)
+        boxes = row.select { |child| cluster?(child) }
+        [MIN_CELL_HEIGHT, *boxes.map { |c| c[:height].to_i + CELL_GAP }].max
+      end
+
+      def shift(contents, delta_x, delta_y)
+        contents.each do |child|
+          child[:x] = child[:x].to_i + delta_x
+          child[:y] = child[:y].to_i + delta_y
+        end
+      end
+
+      def low(contents, axis)
+        contents.map { |child| child[axis].to_i }.min
+      end
+
+      def high(contents, axis, size)
+        contents.map { |child| child[axis].to_i + child[size].to_i }.max
+      end
+    end
+  end
+end

data/lib/etassia/layout/info.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../diagram/info"
+require_relative "../notation/mermaid/ir_adapters/info"
+
+module Etassia
+  module Layout
+    # Info diagram transformer for converting info models to renderable
+    # structure.
+    #
+    # Info diagrams have no complex layout requirements - they simply display
+    # an informational message. This transformer prepares basic data for
+    # rendering.
+    #
+    # @example Transform an info diagram
+    #   layout = Info.new
+    #   scene = layout.call(info_diagram)
+    class Info < Base
+      WIDTH = 400
+      HEIGHT = 100
+      VERSION_TEXT = "v11.12.0"
+      VERSION_FONT_RATIO = [8, 5].freeze
+      private_constant :VERSION_FONT_RATIO
+
+      class Label < Lutaml::Model::Serializable
+        attribute :text, :string
+        attribute :x, :float
+        attribute :y, :float
+        attribute :font_size, :float
+        attribute :text_anchor, :string
+        attribute :font_weight, :string
+      end
+
+      class Scene < Layout::Scene
+        attribute :id, :string
+        attribute :title, :string
+        attribute :view_box, :string
+        attribute :label, Label
+      end
+
+      def self.from_graph(graph, theme: nil)
+        layout = new
+        layout.theme = theme if theme
+        layout.send(:scene_from_graph, graph)
+      end
+
+      # Converts an info diagram to a simple data structure.
+      #
+      # Info diagrams don't need layout computation. This method validates
+      # the diagram and returns a structure for the renderer.
+      #
+      # @param diagram [Diagram::Info] the info diagram to transform
+      # @return [Hash] data structure for rendering
+      def build_graph(diagram)
+        data = ir_data(diagram)
+        {
+          id: data.id, title: data.label,
+          show_info: data_value(data, "show_information", false),
+          metadata: {
+            diagram_type: :info,
+          }
+        }
+      end
+
+      private
+
+      def scene(diagram)
+        scene_from_graph(build_graph(diagram))
+      end
+
+      def ir_data(diagram)
+        return diagram if diagram.is_a?(IR::Data)
+
+        Notation::Mermaid::IRAdapters::Info.call(diagram)
+      end
+
+      def data_value(data, role, fallback)
+        entry = data.values.find { |value| value.role == role }
+        entry ? entry.value.value : fallback
+      end
+
+      # mmdc draws only the mermaid version, centred at (100, 40) in a
+      # 400x100 canvas (mermaid's infoRenderer:
+      # configureSvgSize(svg, 100, 400)).
+      def scene_from_graph(graph)
+        Scene.new(
+          id: graph[:id] || "info", title: graph[:title],
+          width: WIDTH, height: HEIGHT, view_box: "0 0 #{WIDTH} #{HEIGHT}",
+          label: version_label
+        )
+      end
+
+      def version_label
+        Label.new(
+          text: VERSION_TEXT, x: 100, y: 40,
+          font_size: version_font_size,
+          text_anchor: "middle", font_weight: nil
+        )
+      end
+
+      def version_font_size
+        typography = theme.typography
+        title_size = typography.font_size_title if
+          typography.respond_to?(:font_size_title)
+        title_size ||=
+          Theme::Registry.get(:default).typography.font_size_title
+        numerator, denominator = VERSION_FONT_RATIO
+        title_size * numerator / denominator
+      end
+    end
+  end
+end