etassia 0.1.0

data/lib/etassia/renderer/error.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/error"
+require_relative "../svg/document"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "../svg/circle"
+require_relative "../svg/path"
+
+module Etassia
+  module Renderer
+    # Error diagram renderer for converting error diagrams to SVG.
+    #
+    # Renders an error message box with a warning icon and error text.
+    #
+    # @example Render an error diagram
+    #   renderer = Error.new
+    #   svg = renderer.render(error_diagram)
+    class Error < Base
+      # Renders an error diagram to SVG.
+      #
+      # @param scene [Layout::Error::Scene] the final error scene
+      # @return [Svg::Document] the rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+
+        # Render error box
+        render_error_box(scene, svg)
+
+        # Render error icon
+        render_error_icon(scene, svg)
+
+        # Render error text
+        render_error_text(scene, svg)
+
+        svg
+      end
+
+      protected
+
+      def render_error_box(scene, svg)
+        geometry = scene.box
+        box = rectangle_geometry(geometry)
+        box.fill = theme_color(:surface)
+        box.stroke = theme_color(:error)
+        box.stroke_width = "2"
+        box.rx = geometry.corner_radius
+        box.ry = geometry.corner_radius
+        svg << box
+      end
+
+      def render_error_icon(scene, svg)
+        svg << error_icon_circle(scene.icon)
+        svg << error_icon_mark(scene.mark)
+        svg << error_icon_dot(scene.dot)
+      end
+
+      def render_error_text(scene, svg)
+        [scene.label, scene.version_label].each do |label|
+          svg << text_element(label)
+        end
+      end
+
+      def text_element(label)
+        Svg::Text.new.tap do |text|
+          position_error_text(text, label)
+          text.content = label.text
+          style_error_text(text, label)
+        end
+      end
+
+      def number_string(value)
+        value.to_i == value ? value.to_i.to_s : value.to_s
+      end
+
+      private
+
+      def rectangle_geometry(geometry)
+        Svg::Rect.new.tap do |rect|
+          rect.x = geometry.x
+          rect.y = geometry.y
+          rect.width = geometry.width
+          rect.height = geometry.height
+        end
+      end
+
+      def circle_geometry(geometry)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = geometry.x
+          circle.cy = geometry.y
+          circle.r = geometry.radius
+        end
+      end
+
+      def error_icon_circle(geometry)
+        circle_geometry(geometry).tap do |circle|
+          circle.fill = theme_color(:error)
+          circle.stroke = theme_color(:edge_stroke)
+          circle.stroke_width = "2"
+        end
+      end
+
+      def error_icon_mark(geometry)
+        rectangle_geometry(geometry).tap do |rect|
+          rect.fill = theme_color(:background)
+          rect.rx = geometry.corner_radius
+        end
+      end
+
+      def error_icon_dot(geometry)
+        circle_geometry(geometry).tap do |circle|
+          circle.fill = theme_color(:background)
+        end
+      end
+
+      def position_error_text(text, label)
+        text.x = label.x
+        text.y = label.y
+      end
+
+      def style_error_text(text, label)
+        text.fill = theme_color(:error)
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = number_string(label.font_size)
+        text.text_anchor = label.text_anchor
+        text.font_weight = label.font_weight
+      end
+    end
+  end
+end

data/lib/etassia/renderer/flowchart.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/flowchart"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed flowchart geometry.
+    class Flowchart < Base
+      LINK_THICK_MULTIPLE = 3.5
+      LINK_DOTTED_DASHES = "2"
+      CIRCLE_HEAD_STROKE = "1"
+      CROSS_HEAD_STROKE = "2"
+
+      private_constant :LINK_THICK_MULTIPLE, :LINK_DOTTED_DASHES,
+                       :CIRCLE_HEAD_STROKE, :CROSS_HEAD_STROKE
+
+      # @param scene [Layout::Flowchart::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document(scene, overflow: "hidden")
+
+        # Mermaid paints cluster surfaces first, then edges, then nodes.
+        render_clusters(scene.children, svg)
+        scene.edges.each { |edge| render_edge(edge, svg) }
+        render_nodes(scene.children, svg)
+
+        svg
+      end
+
+      protected
+
+      def render_clusters(nodes, svg)
+        nodes.each do |node|
+          render_cluster(node, svg) if node.cluster
+          render_clusters(node.children, svg)
+        end
+      end
+
+      def render_cluster(cluster, svg)
+        group = Svg::Group.new.tap { |item| item.id = "cluster-#{cluster.id}" }
+        group.children << cluster_box(cluster)
+        append_cluster_title(group, cluster)
+        svg << group
+      end
+
+      def append_cluster_title(group, cluster)
+        return if cluster.labels.empty?
+
+        group.children << cluster_title(cluster.labels.first)
+      end
+
+      def cluster_box(cluster)
+        Svg::Rect.new.tap do |rect|
+          assign_cluster_geometry(rect, cluster)
+          apply_theme_to_cluster(rect)
+        end
+      end
+
+      def assign_cluster_geometry(rect, cluster)
+        rect.x = cluster.shape_x
+        rect.y = cluster.shape_y
+        rect.width = cluster.shape_width
+        rect.height = cluster.shape_height
+        rect.rx = cluster.corner_radius
+        rect.ry = cluster.corner_radius
+      end
+
+      def cluster_title(label)
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.y
+          text.content = label.text
+          apply_flowchart_text_style(text, label)
+          text.text_anchor = "middle"
+          text.dominant_baseline = "middle"
+        end
+      end
+
+      def fill_node_lines(text, label)
+        return text.content = label.text if label.runs.empty?
+
+        text.dominant_baseline = nil
+        text.tspans = label.runs.map { |run| text_run(run) }
+      end
+
+      def text_run(run)
+        Svg::Tspan.new.tap do |tspan|
+          tspan.x = run.x
+          tspan.y = run.y if run.y
+          tspan.content = run.content
+        end
+      end
+
+      def apply_theme_to_cluster(element)
+        if theme_color(:surface_variant)
+          element.fill = theme_color(:surface_variant)
+        end
+        element.stroke = theme_color(:node_stroke) if theme_color(:node_stroke)
+        if theme_shape(:stroke_width)
+          element.stroke_width = theme_shape(:stroke_width).to_s
+        end
+      end
+
+      def render_nodes(nodes, svg)
+        nodes.each do |node|
+          render_node(node, svg) unless node.container
+          render_nodes(node.children, svg)
+        end
+      end
+
+      def render_node(node, svg)
+        group = Svg::Group.new.tap { |item| item.id = "node-#{node.id}" }
+        group.children << painted_node_shape(node)
+        append_node_label(group, node)
+        svg << group
+      end
+
+      def append_node_label(group, node)
+        return if node.labels.empty?
+
+        group.children << node_label(node.labels.first)
+      end
+
+      def painted_node_shape(node)
+        node_shape(node).tap do |shape|
+          fill = Diagram::FlowchartNode.paint_value(node.fill)
+          stroke = Diagram::FlowchartNode.paint_value(node.stroke)
+          shape.fill = fill if fill
+          shape.stroke = stroke if stroke
+        end
+      end
+
+      def node_shape(node)
+        case node.shape_kind
+        when "rounded", "stadium" then rounded_rectangle(node)
+        when "circle" then circle(node)
+        when "rhombus", "hexagon" then polygon(node)
+        else rectangle(node)
+        end
+      end
+
+      def rectangle(node)
+        Svg::Rect.new.tap do |rect|
+          rect.x = node.shape_x
+          rect.y = node.shape_y
+          rect.width = node.shape_width
+          rect.height = node.shape_height
+          apply_theme_to_node(rect)
+        end
+      end
+
+      def rounded_rectangle(node)
+        rectangle(node).tap do |rect|
+          rect.rx = node.corner_radius
+          rect.ry = node.corner_radius
+        end
+      end
+
+      def circle(node)
+        Svg::Circle.new.tap do |item|
+          item.cx = node.center_x
+          item.cy = node.center_y
+          item.r = node.radius
+          apply_theme_to_node(item)
+        end
+      end
+
+      def polygon(node)
+        Svg::Polygon.new.tap do |item|
+          item.points = node.shape_points
+          apply_theme_to_node(item)
+        end
+      end
+
+      def node_label(label)
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.text_y || label.y
+          apply_flowchart_text_style(text, label)
+          text.text_anchor = "middle"
+          text.dominant_baseline = "middle"
+          fill_node_lines(text, label)
+        end
+      end
+
+      def render_edge(edge, svg)
+        svg << edge_group(edge)
+      end
+
+      def edge_group(edge)
+        Svg::Group.new.tap do |group|
+          group.id = "edge-#{edge.id}"
+          append_edge_geometry(group, edge)
+        end
+      end
+
+      def append_edge_geometry(group, edge)
+        group.children << edge_path(edge)
+        edge.heads.each { |head| group.children.concat(head_elements(head)) }
+        append_edge_label(group, edge)
+      end
+
+      def append_edge_label(group, edge)
+        return if edge.labels.empty?
+
+        label = edge.labels.first
+        group.children << edge_label_backdrop(label)
+        group.children << edge_label(label)
+      end
+
+      def edge_path(edge)
+        Svg::Path.new.tap do |path|
+          path.d = edge.path
+          path.fill = "none"
+          apply_theme_to_edge(path)
+          apply_link_weight(path, edge.arrow_type)
+          path.stroke = "none" if edge.arrow_type == "invisible"
+        end
+      end
+
+      def apply_link_weight(path, type)
+        path.stroke_width = thick_width.to_s if type.start_with?("thick_")
+        path.stroke_dasharray = dotted_dashes if type.start_with?("dotted_")
+      end
+
+      def thick_width
+        theme_shape(:stroke_width_thick) ||
+          ((theme_shape(:stroke_width) || 1.0) * LINK_THICK_MULTIPLE)
+      end
+
+      def dotted_dashes
+        theme_shape(:dash_pattern_dotted) || LINK_DOTTED_DASHES
+      end
+
+      def head_elements(head)
+        case head.shape
+        when "cross" then cross_head(head)
+        when "circle" then [circle_head(head)]
+        else [arrow_head(head)]
+        end
+      end
+
+      def arrow_head(head)
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = head.points
+          polygon.fill = edge_ink || "none"
+          polygon.stroke = edge_ink
+        end
+      end
+
+      def circle_head(head)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = head.x
+          circle.cy = head.y
+          circle.r = head.radius
+          circle.fill = edge_ink || "none"
+          circle.stroke = edge_ink
+          circle.stroke_width = CIRCLE_HEAD_STROKE
+        end
+      end
+
+      def cross_head(head)
+        head.lines.map { |geometry| cross_line(geometry) }
+      end
+
+      def cross_line(geometry)
+        Svg::Line.new.tap do |line|
+          line.x1 = geometry.x1
+          line.y1 = geometry.y1
+          line.x2 = geometry.x2
+          line.y2 = geometry.y2
+          line.stroke = edge_ink
+          line.stroke_width = CROSS_HEAD_STROKE
+        end
+      end
+
+      def edge_ink
+        theme_color(:edge_stroke)
+      end
+
+      def edge_label_backdrop(label)
+        font_size = label.font_size || Layout::Flowchart::DEFAULT_FONT_SIZE
+        bounds = label.backdrop_geometry(font_size: font_size)
+        Svg::Rect.new(x: bounds.x, y: bounds.y,
+                      width: bounds.width, height: bounds.height,
+                      fill: edge_label_background_color, stroke: "none")
+      end
+
+      def edge_label_background_color
+        theme_color(:background) ||
+          Theme::Registry.get(:default).colors.background
+      end
+
+      def edge_label(label)
+        Svg::Text.new.tap do |text|
+          assign_edge_label_geometry(text, label)
+          apply_flowchart_text_style(text, label)
+          text.text_anchor = "middle"
+        end
+      end
+
+      def assign_edge_label_geometry(text, label)
+        text.x = label.x
+        text.y = label.y
+        text.content = label.text
+      end
+
+      def apply_flowchart_text_style(text, label)
+        apply_theme_to_text(text)
+        text.font_size = label.font_size.to_s
+      end
+    end
+  end
+end

data/lib/etassia/renderer/gantt.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/gantt"
+require_relative "../svg/document"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "../svg/line"
+require_relative "../svg/polygon"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed Gantt geometry.
+    class Gantt < Base
+      MARGIN_LEFT = Layout::Gantt::MARGIN_LEFT
+      MARGIN_TOP = Layout::Gantt::MARGIN_TOP
+      MARGIN_RIGHT = Layout::Gantt::MARGIN_RIGHT
+      MARGIN_BOTTOM = Layout::Gantt::MARGIN_BOTTOM
+      ROW_HEIGHT = Layout::Gantt::ROW_HEIGHT
+      SECTION_HEIGHT = Layout::Gantt::SECTION_HEIGHT
+      TASK_BAR_HEIGHT = Layout::Gantt::TASK_BAR_HEIGHT
+      TIMELINE_WIDTH = Layout::Gantt::TIMELINE_WIDTH
+      TIMELINE_HEIGHT = Layout::Gantt::TIMELINE_HEIGHT
+      TITLE_Y = Layout::Gantt::TITLE_Y
+
+      TASK_COLOR_ROLES = {
+        done: :success,
+        active: :info,
+        critical: :error,
+        default: :primary,
+      }.freeze
+      TASK_COLORS = begin
+        colors = Theme::Registry.get(:default).colors
+        TASK_COLOR_ROLES.transform_values { |role| colors.public_send(role) }
+          .freeze
+      end
+
+      # @param scene [Layout::Gantt::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        validate_scene!(scene)
+        svg = create_document(scene)
+        svg << text_element(scene.title) if scene.title
+        render_timeline(scene.timeline, svg) if scene.timeline
+        scene.sections.each { |section| render_section(section, svg) }
+        svg
+      end
+
+      protected
+
+      def validate_scene!(scene)
+        return if scene.is_a?(Layout::Gantt::Scene)
+
+        raise RenderError,
+              "expected #{Layout::Gantt::Scene}, got #{scene.class}"
+      end
+
+      def render_timeline(timeline, svg)
+        svg << timeline_background(timeline.background)
+        timeline.labels.each { |label| svg << text_element(label) }
+        timeline.grid_lines.each { |line| svg << grid_line(line) }
+      end
+
+      def timeline_background(geometry)
+        Svg::Rect.new.tap do |rect|
+          apply_rect_geometry(rect, geometry)
+          rect.fill = theme_color(:node_fill)
+          rect.stroke = theme_color(:node_stroke)
+          rect.stroke_width = "1"
+        end
+      end
+
+      def grid_line(geometry)
+        Svg::Line.new.tap do |line|
+          apply_line_geometry(line, geometry)
+          apply_grid_line_style(line)
+        end
+      end
+
+      def apply_line_geometry(line, geometry)
+        line.x1 = geometry.x1
+        line.y1 = geometry.y1
+        line.x2 = geometry.x2
+        line.y2 = geometry.y2
+      end
+
+      def apply_grid_line_style(line)
+        line.stroke = theme_color(:node_stroke)
+        line.stroke_width = "1"
+        line.stroke_dasharray = "2,2"
+      end
+
+      def render_section(section, svg)
+        svg << section_background(section.background)
+        svg << text_element(section.label)
+        section.tasks.each { |task| render_task(task, svg) }
+      end
+
+      def section_background(geometry)
+        Svg::Rect.new.tap do |rect|
+          apply_rect_geometry(rect, geometry)
+          rect.fill = theme_color(:section_bg)
+          rect.stroke = "none"
+        end
+      end
+
+      def render_task(task, svg)
+        svg << text_element(task.label)
+        colour = theme_color(TASK_COLOR_ROLES.fetch(task.status.to_sym))
+        render_task_shape(task, svg, colour)
+      end
+
+      def render_task_shape(task, svg, colour)
+        if task.milestone_points
+          return svg << milestone(task.milestone_points, colour)
+        end
+        return unless task.bar
+
+        svg << task_bar(task.bar, colour)
+        render_task_id(task.id_label, svg)
+      end
+
+      def render_task_id(label, svg)
+        svg << text_element(label, fill: "#ffffff") if label
+      end
+
+      def task_bar(geometry, colour)
+        Svg::Rect.new.tap do |rect|
+          apply_rect_geometry(rect, geometry)
+          rect.fill = colour
+          rect.stroke = theme_color(:node_stroke)
+          rect.stroke_width = "1"
+          rect.rx = geometry.corner_radius
+          rect.ry = geometry.corner_radius
+        end
+      end
+
+      def milestone(points, colour)
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = points
+          polygon.fill = colour
+          polygon.stroke = theme_color(:node_stroke)
+          polygon.stroke_width = "2"
+        end
+      end
+
+      def apply_rect_geometry(rect, geometry)
+        rect.x = geometry.x
+        rect.y = geometry.y
+        rect.width = geometry.width
+        rect.height = geometry.height
+      end
+
+      def text_element(geometry, fill: nil)
+        Svg::Text.new.tap do |text|
+          apply_text_geometry(text, geometry)
+          apply_text_style(text, geometry, fill)
+        end
+      end
+
+      def apply_text_geometry(text, geometry)
+        text.x = geometry.x
+        text.y = geometry.y
+        text.content = geometry.text
+        text.text_anchor = geometry.text_anchor
+        text.dominant_baseline = geometry.dominant_baseline
+      end
+
+      def apply_text_style(text, geometry, fill)
+        text.fill = fill || theme_color(:label_text)
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = geometry.font_size.to_s
+        text.font_weight = geometry.font_weight
+      end
+    end
+  end
+end