etassia 0.1.0

data/lib/etassia/renderer/state_diagram.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/state_diagram"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed state-diagram geometry.
+    class StateDiagram < Base
+      LAYOUT_SCENE = Layout::StateDiagram::Scene
+      private_constant :LAYOUT_SCENE
+
+      # @param scene [Layout::StateDiagram::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        require_typed_scene!(scene)
+        svg = create_document(scene)
+        render_transitions(scene, svg)
+        render_states(scene, svg)
+        svg
+      end
+
+      protected
+
+      def require_typed_scene!(scene)
+        return if scene.is_a?(LAYOUT_SCENE)
+
+        raise ArgumentError, "StateDiagram renderer requires a typed Scene"
+      end
+
+      def render_states(scene, svg)
+        scene.children.each { |state| render_state(state, svg) }
+      end
+
+      def render_state(state, parent)
+        parent << state_group(state)
+      end
+
+      def state_group(state)
+        group = Svg::Group.new.tap { |item| item.id = "state-#{state.id}" }
+        group.children << final_state_shape(state)
+        append_state_labels(state, group)
+        state.children.each do |child|
+          render_state(child, group)
+        end
+        group
+      end
+
+      def render_transitions(scene, svg)
+        scene.edges.each { |edge| render_transition(edge, svg) }
+      end
+
+      def render_transition(edge, svg)
+        group = Svg::Group.new.tap { |item| item.id = "transition-#{edge.id}" }
+        group.children << transition_path(edge)
+        append_transition_label(edge, group)
+        svg << group
+      end
+
+      def transition_label(label)
+        label_text(label)
+      end
+
+      private
+
+      def final_state_shape(state)
+        case state.shape_type
+        when "start" then start_state_shape(state)
+        when "end" then end_state_shape(state)
+        when "choice" then choice_state_shape(state)
+        when "fork", "join" then fork_join_state_shape(state)
+        when "note" then note_state_shape(state)
+        else normal_state_shape(state.x, state.y, state.width, state.height)
+        end
+      end
+
+      def note_state_shape(state)
+        normal_state_shape(
+          state.x, state.y, state.width, state.height
+        ).tap do |rect|
+          rect.rx = nil
+          rect.ry = nil
+          rect.fill = "#fff5ad"
+          rect.stroke = "#aaaa33"
+          rect.stroke_width = "1"
+        end
+      end
+
+      def normal_state_shape(x_position, y_position, width, height)
+        Svg::Rect.new.tap do |rect|
+          rect.x = x_position
+          rect.y = y_position
+          rect.width = width
+          rect.height = height
+          rect.rx = 10
+          rect.ry = 10
+          apply_normal_state_style(rect)
+          rect.stroke_width = "2"
+        end
+      end
+
+      def apply_normal_state_style(rect)
+        rect.fill = theme_color(:node_fill)
+        rect.stroke = theme_color(:node_stroke)
+      end
+
+      def start_state_shape(state)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = state.center_x
+          circle.cy = state.center_y
+          circle.r = state.radius
+          circle.fill = theme_color(:node_stroke)
+          circle.stroke = "none"
+        end
+      end
+
+      def end_state_shape(state)
+        Svg::Group.new.tap do |group|
+          group.children << state_circle(state, state.radius, "none", "2")
+          group.children << state_circle(
+            state, state.inner_radius, theme_color(:node_stroke), nil
+          )
+        end
+      end
+
+      def choice_state_shape(state)
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = state.shape_points
+          polygon.fill = theme_color(:node_fill)
+          polygon.stroke = theme_color(:node_stroke)
+          polygon.stroke_width = "2"
+        end
+      end
+
+      def fork_join_state_shape(state)
+        Svg::Rect.new.tap do |rect|
+          rect.x = state.x
+          rect.y = state.shape_y
+          rect.width = state.width
+          rect.height = state.shape_height
+          rect.fill = theme_color(:node_stroke)
+          rect.stroke = "none"
+        end
+      end
+
+      def state_circle(state, radius, fill, stroke_width)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = state.center_x
+          circle.cy = state.center_y
+          circle.r = radius
+          circle.fill = fill
+          circle.stroke = fill == "none" ? theme_color(:node_stroke) : "none"
+          circle.stroke_width = stroke_width
+        end
+      end
+
+      def append_state_labels(state, group)
+        state.labels.each { |label| group.children << state_label(label) }
+      end
+
+      def append_transition_label(edge, group)
+        if edge.labels.any?
+          group.children << transition_label(edge.labels.first)
+        end
+      end
+
+      def transition_path(edge)
+        Svg::Path.new.tap do |path|
+          path.d = edge.path
+          path.fill = "none"
+          path.stroke = theme_color(:edge_stroke)
+          path.stroke_width = "2"
+          path.marker_end = "url(#arrowhead)"
+        end
+      end
+
+      def state_label(label)
+        label_text(label).tap { |text| text.dominant_baseline = "middle" }
+      end
+
+      def label_text(label)
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.y
+          text.content = label.text
+          apply_label_style(text, label)
+        end
+      end
+
+      def apply_label_style(text, label)
+        text.fill = theme_color(:label_text)
+        text.font_family = "Arial, sans-serif"
+        text.font_size = formatted_number(label.font_size)
+        text.text_anchor = "middle"
+      end
+
+      def formatted_number(number)
+        number.to_i == number ? number.to_i.to_s : number.to_s
+      end
+    end
+  end
+end

data/lib/etassia/renderer/timeline.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "line_break_text"
+require_relative "timeline_palette"
+require_relative "../layout/timeline"
+require_relative "../svg/document"
+require_relative "../svg/group"
+require_relative "../svg/line"
+require_relative "../svg/path"
+require_relative "../svg/text"
+require_relative "../svg/tspan"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed timeline geometry.
+    class Timeline < Base
+      FONT_FAMILY = "Trebuchet MS, Verdana, Arial, sans-serif"
+      CARD_WRAPPERS = {
+        "section" => nil, "period" => "taskWrapper", "event" => "eventWrapper"
+      }.freeze
+      ARROW = "url(#arrowhead)"
+
+      # @param scene [Layout::Timeline::Scene] final timeline geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        validate_scene!(scene)
+        svg = create_document(scene)
+        scene.cards.each { |card| render_card(card, svg) }
+        svg << title_element(scene) if scene.title
+        svg << line_group(scene.axis)
+        svg
+      end
+
+      protected
+
+      def validate_scene!(scene)
+        return if scene.is_a?(Layout::Timeline::Scene)
+
+        raise RenderError,
+              "expected #{Layout::Timeline::Scene}, got #{scene.class}"
+      end
+
+      def render_card(card, svg)
+        svg << card_group(card)
+        svg << line_group(card.connector) if card.connector
+      end
+
+      def card_group(card)
+        wrapper = Svg::Group.new(class_name: CARD_WRAPPERS.fetch(card.kind))
+        wrapper.tap { |group| group << node_group(card) }
+      end
+
+      def node_group(card)
+        fill, text, rule = TimelinePalette.for(theme.colors, card.color_index)
+        Svg::Group.new(class_name: "timeline-node").tap do |node|
+          node << background(card, fill, rule)
+          node << text_element(card, text)
+        end
+      end
+
+      def background(card, fill, rule)
+        Svg::Group.new.tap do |group|
+          group << Svg::Path.new(d: card.outline, fill: fill,
+                                 class_name: "node-bkg")
+          group << rule_line(card.rule, rule)
+        end
+      end
+
+      def rule_line(line, stroke)
+        Svg::Line.new(
+          x1: number(line.x1), y1: number(line.y1),
+          x2: number(line.x2), y2: number(line.y2),
+          stroke: stroke, stroke_width: "3", class_name: "node-line"
+        )
+      end
+
+      def text_element(card, color)
+        text = Svg::Text.new(
+          x: number(card.text_x), y: number(card.text_y), fill: color,
+          font_family: FONT_FAMILY, font_size: number(card.font_size),
+          text_anchor: "middle"
+        )
+        fill_text(text, card)
+      end
+
+      def fill_text(text, card)
+        if card.text_runs.length < 2
+          text.content = card.text_runs.first&.content.to_s
+        else
+          text.tspans = card.text_runs.map { |run| tspan(run) }
+        end
+        text
+      end
+
+      def tspan(geometry)
+        Svg::Tspan.new(x: geometry.x, y: geometry.y).tap do |run|
+          run.content = geometry.content
+        end
+      end
+
+      def title_element(scene)
+        text = Svg::Text.new(
+          x: scene.title_x, y: scene.title_y,
+          fill: theme_color(:label_text),
+          font_family: FONT_FAMILY, font_size: number(scene.title_size),
+          font_weight: "bold"
+        )
+        LineBreakText.fill(text, scene.title)
+      end
+
+      def line_group(line)
+        Svg::Group.new(class_name: "lineWrapper").tap do |group|
+          group << arrow_path(line)
+        end
+      end
+
+      def arrow_path(line)
+        Svg::Path.new(
+          d: "M #{number(line.x1)} #{number(line.y1)} " \
+             "L #{number(line.x2)} #{number(line.y2)}",
+          fill: "none", stroke: theme_color(:edge_stroke),
+          marker_end: ARROW,
+          stroke_width: number(line.stroke_width),
+          stroke_dasharray: ("5,5" if line.dashed)
+        )
+      end
+
+      def number(value)
+        value.to_i == value ? value.to_i.to_s : value.to_s
+      end
+    end
+  end
+end

data/lib/etassia/renderer/timeline_palette.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Renderer
+    # Reads the twelve section colours of mermaid's default theme from the
+    # theme: card fill, text colour and the rule under each card.
+    module TimelinePalette
+      # @param colors [Theme::ColorPalette] the theme's colours
+      # @param index [Integer] section number, counted from 0
+      # @return [Array<String>] [fill, text, rule] colours
+      def self.for(colors, index)
+        %i[timeline_fill timeline_text timeline_rule].map do |name|
+          colors.palette(name, index)
+        end
+      end
+    end
+  end
+end

data/lib/etassia/renderer/treemap/section_total.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Renderer
+    class Treemap < Base
+      # Sums the leaf values under a section so the section can show a total,
+      # as mmdc does. The layout only labels leaves.
+      class SectionTotal
+        def initialize(cell)
+          @cell = cell
+        end
+
+        # The formatted total, or nil when the section has no leaf values.
+        def text
+          leaves = leaf_values(@cell)
+          return if leaves.empty?
+
+          total = leaves.sum
+          total == total.to_i ? total.to_i.to_s : format("%.1f", total)
+        end
+
+        private
+
+        def leaf_values(cell)
+          return cell.children.flat_map { |kid| leaf_values(kid) } if
+            cell.children.any?
+
+          cell.value_label ? [Float(cell.value_label.text)] : []
+        end
+      end
+    end
+  end
+end

data/lib/etassia/renderer/treemap.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/treemap"
+require_relative "../svg/document"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "../svg/group"
+require_relative "treemap/section_total"
+
+module Etassia
+  module Renderer
+    # Renderer for treemap diagrams
+    class Treemap < Base
+      def render(layout)
+        scene = typed_scene(layout)
+        doc = create_document(scene)
+
+        add_title(doc, scene.title) if scene.title
+
+        scene.cells.each { |cell| render_cell(doc, cell) }
+
+        doc
+      end
+
+      private
+
+      def typed_scene(layout)
+        return layout if layout.is_a?(Layout::Treemap::Scene)
+
+        Layout::Treemap.from_graph(layout, theme: theme)
+      end
+
+      def add_title(doc, label)
+        doc << Svg::Text.new.tap do |text|
+          set_title_geometry(text, label)
+          set_title_style(text, label)
+        end
+      end
+
+      def set_title_geometry(text, label)
+        text.content = label.text
+        text.x = label.x
+        text.y = label.y
+        text.text_anchor = label.text_anchor
+      end
+
+      def set_title_style(text, label)
+        text.fill = label_fill("#333")
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = number_string(label.font_size)
+        text.font_weight = label.font_weight
+      end
+
+      def render_cell(doc, cell, parent_group = nil)
+        group = cell_group(cell)
+        cell.children.each { |child| render_cell(group, child, group) }
+        (parent_group || doc) << group
+      end
+
+      def cell_group(cell)
+        Svg::Group.new.tap do |group|
+          group << cell_box(cell)
+          group << label_element(cell.label)
+          group << label_element(cell.value_label) if cell.value_label
+          add_section_total(group, cell)
+        end
+      end
+
+      def cell_box(cell)
+        Svg::Rect.new.tap do |rect|
+          set_cell_box_geometry(rect, cell.box)
+          rect.fill = cell.fill
+          rect.stroke = cell.stroke
+          rect.stroke_width = "2"
+        end
+      end
+
+      def set_cell_box_geometry(rect, box)
+        rect.x = box.x
+        rect.y = box.y
+        rect.width = box.width
+        rect.height = box.height
+        rect.rx = box.corner_radius
+        rect.ry = box.corner_radius
+      end
+
+      def add_section_total(group, cell)
+        return unless cell.total_label&.text
+
+        group << label_element(cell.total_label)
+      end
+
+      def label_element(label, content: label.text)
+        Svg::Text.new.tap do |text|
+          set_label_geometry(text, label, content)
+          set_label_style(text, label)
+        end
+      end
+
+      def set_label_geometry(text, label, content)
+        text.content = content
+        text.x = label.x
+        text.y = label.y
+        text.text_anchor = label.text_anchor if label.text_anchor
+      end
+
+      def set_label_style(text, label)
+        text.fill = label_fill(label_fallback(label))
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = number_string(label.font_size)
+        text.font_weight = label.font_weight if label.font_weight
+      end
+
+      def label_fill(fallback)
+        theme ? theme_color(:label_text) : fallback
+      end
+
+      def label_fallback(label)
+        label.style == "value" ? "#666" : "#333"
+      end
+
+      def number_string(value)
+        value.to_i == value ? value.to_i.to_s : value.to_s
+      end
+    end
+  end
+end