etassia 0.1.0

data/lib/etassia/renderer/block.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/block"
+
+module Etassia
+  module Renderer
+    # Block diagram renderer for converting positioned layouts to SVG.
+    #
+    # Converts a positioned block diagram layout into SVG using the Svg
+    # builder classes. Handles different block shapes, compound blocks,
+    # and connections.
+    #
+    # @example Render a block diagram
+    #   renderer = Block.new
+    #   svg = renderer.render(layout)
+    class Block < Base
+      # Renders a positioned layout to SVG.
+      #
+      # @param scene [Layout::Block::Scene] final canvas geometry
+      # @return [Svg::Document] the rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        render_connections(scene, svg)
+        render_blocks(scene, svg)
+
+        svg
+      end
+
+      protected
+
+      def render_blocks(scene, svg)
+        scene.children.each { |node| render_block(node, svg) }
+      end
+
+      def render_block(node, svg)
+        group = if node.compound
+                  compound_block_group(node)
+                else
+                  block_group(node)
+                end
+        svg << group
+      end
+
+      def compound_block_group(node)
+        group = named_block_group(node)
+        group.children << create_compound_border(node)
+        node.children.each { |child| group.children << block_group(child) }
+        group
+      end
+
+      def block_group(node)
+        group = named_block_group(node)
+        group.children << create_block_shape(node)
+        group.children << create_block_label(node) unless node.labels.empty?
+        group
+      end
+
+      def named_block_group(node)
+        Svg::Group.new.tap { |group| group.id = "block-#{node.id}" }
+      end
+
+      def create_compound_border(node)
+        Svg::Rect.new.tap do |rect|
+          apply_node_geometry(rect, node)
+          rect.fill = "none"
+          rect.stroke = theme_color(:edge_color)
+          rect.stroke_width = "2"
+          rect.stroke_dasharray = "5,5"
+        end
+      end
+
+      def create_block_shape(node)
+        case node.shape
+        when "circle"
+          create_circle_block(node)
+        when "arrow"
+          create_arrow_block(node)
+        else
+          create_rectangle_block(node)
+        end
+      end
+
+      def create_rectangle_block(node)
+        Svg::Rect.new.tap do |rect|
+          apply_node_geometry(rect, node)
+          apply_theme_to_node(rect)
+        end
+      end
+
+      def apply_node_geometry(shape, node)
+        shape.x = node.x
+        shape.y = node.y
+        shape.width = node.width
+        shape.height = node.height
+      end
+
+      def create_circle_block(node)
+        circle = Svg::Circle.new(
+          cx: node.center_x,
+          cy: node.center_y,
+          r: node.radius,
+        )
+        apply_theme_to_node(circle)
+        circle
+      end
+
+      def create_arrow_block(node)
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = node.shape_points
+          apply_theme_to_node(polygon)
+        end
+      end
+
+      def create_block_label(node)
+        label = node.labels.first
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.y
+          text.content = label.text
+          apply_theme_to_text(text)
+          text.text_anchor = "middle"
+          text.dominant_baseline = "middle"
+        end
+      end
+
+      def render_connections(scene, svg)
+        scene.edges.each { |edge| render_connection(edge, svg) }
+      end
+
+      def render_connection(edge, svg)
+        group = Svg::Group.new
+        group.id = "connection-#{edge.source}-#{edge.target}"
+        group.children << connection_path(edge)
+        svg << group
+      end
+
+      def connection_path(edge)
+        Svg::Path.new.tap do |path|
+          path.d = calculate_connection_path(edge)
+          path.fill = "none"
+          apply_theme_to_edge(path)
+          if edge.connection_type == "arrow"
+            path.marker_end = "url(#arrowhead)"
+          end
+        end
+      end
+
+      def calculate_connection_path(edge)
+        section = edge.sections.first
+        start_point = section.start_point
+        end_point = section.end_point
+        "M #{start_point.x} #{start_point.y} L #{end_point.x} #{end_point.y}"
+      end
+    end
+  end
+end

data/lib/etassia/renderer/c4.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/c4"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed C4 geometry.
+    class C4 < Base
+      C4_COLOR_ROLES = {
+        person: { bg: :primary, border: :edge_stroke, text: :background },
+        person_ext: { bg: :secondary, border: :edge_stroke,
+                      text: :background },
+        system: { bg: :primary, border: :edge_stroke, text: :background },
+        system_ext: { bg: :secondary, border: :edge_stroke,
+                      text: :background },
+        container: { bg: :primary, border: :edge_stroke,
+                     text: :background },
+        component: { bg: :surface_variant, border: :node_stroke,
+                     text: :foreground },
+        boundary: { bg: :background, border: :node_stroke,
+                    text: :foreground },
+      }.freeze
+
+      # @param scene [Layout::C4::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        unless scene.is_a?(Layout::C4::Scene)
+          raise RenderError, "C4 renderer requires Layout::C4::Scene"
+        end
+
+        svg = document_for(scene)
+        render_boundaries(scene.children, svg)
+        scene.edges.each { |edge| render_relationship(edge, svg) }
+        render_elements(scene.children, svg)
+        add_title(svg, scene.title)
+        svg
+      end
+
+      protected
+
+      def document_for(scene)
+        create_document(scene, overflow: scene.overflow).tap do |document|
+          document.view_box = scene.view_box
+        end
+      end
+
+      def render_boundaries(nodes, svg)
+        nodes.each do |node|
+          next unless node.kind == "boundary"
+
+          svg << boundary_group(node) if positioned?(node)
+          render_boundaries(node.children, svg)
+        end
+      end
+
+      def boundary_group(node)
+        Svg::Group.new.tap do |group|
+          group.id = "boundary-#{node.id}"
+          group.children << boundary_rect(node)
+          append_boundary_label(group, node)
+        end
+      end
+
+      def boundary_rect(node)
+        colours = element_colours(node)
+        Svg::Rect.new.tap do |rect|
+          apply_box(rect, node)
+          rect.fill = colours[:bg]
+          rect.stroke = colours[:border]
+          rect.stroke_width = "2"
+          rect.stroke_dasharray = "10,5"
+          apply_corner_radius(rect, node)
+        end
+      end
+
+      def render_elements(nodes, svg)
+        nodes.each do |node|
+          if node.kind == "boundary"
+            render_elements(node.children, svg)
+          elsif positioned?(node)
+            svg << element_group(node)
+          end
+        end
+      end
+
+      def element_group(node)
+        Svg::Group.new.tap do |group|
+          group.id = "element-#{node.id}"
+          colours = element_colours(node)
+          group.children << element_box(node, colours)
+          add_person_icon(group, node, colours) if node.kind == "person"
+          add_stereotype(group, node, colours)
+          append_element_labels(group, node, colours)
+        end
+      end
+
+      def add_title(svg, title)
+        svg << label_element(title, theme_color(:foreground)) if title
+      end
+
+      def add_stereotype(group, node, colours)
+        return unless node.stereotype
+
+        group.children << label_element(node.stereotype, colours[:text])
+      end
+
+      def element_colours(node)
+        key = case node.kind
+              when "person" then node.external ? :person_ext : :person
+              when "system" then node.external ? :system_ext : :system
+              else node.kind.to_sym
+              end
+        C4_COLOR_ROLES.fetch(key).transform_values { |role| theme_color(role) }
+      end
+
+      def element_box(node, colours)
+        return plain_box(node, colours) unless node.outline
+
+        shape_group(node.outline, node.rim, colours)
+      end
+
+      def shape_group(body, rim, colours)
+        Svg::Group.new.tap do |group|
+          group.children << shape_path(body, colours[:bg], colours)
+          group.children << shape_path(rim, "none", colours)
+        end
+      end
+
+      def shape_path(data, fill, colours)
+        Svg::Path.new.tap do |path|
+          path.d = data
+          path.fill = fill
+          path.stroke = colours[:border]
+          path.stroke_width = "2"
+        end
+      end
+
+      def plain_box(node, colours)
+        Svg::Rect.new.tap do |rect|
+          apply_box(rect, node)
+          rect.fill = colours[:bg]
+          rect.stroke = colours[:border]
+          rect.stroke_width = "2"
+          apply_corner_radius(rect, node)
+        end
+      end
+
+      def add_person_icon(group, node, colours)
+        group.children << person_head(node, colours[:text])
+        group.children << person_body(node, colours[:text])
+      end
+
+      def person_head(node, colour)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = node.head.cx
+          circle.cy = node.head.cy
+          circle.r = node.head.radius
+          circle.fill = colour
+        end
+      end
+
+      def person_body(node, colour)
+        Svg::Ellipse.new.tap do |ellipse|
+          apply_ellipse(ellipse, node.body)
+          ellipse.fill = colour
+        end
+      end
+
+      def apply_ellipse(ellipse, geometry)
+        ellipse.cx = geometry.cx
+        ellipse.cy = geometry.cy
+        ellipse.rx = geometry.radius_x
+        ellipse.ry = geometry.radius_y
+      end
+
+      def label_element(label, colour)
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.y
+          text.content = label.text
+          text.fill = colour
+          style_label(text, label)
+        end
+      end
+
+      def style_label(text, label)
+        text.font_family = label_font_family
+        text.font_size = label.font_size.to_s
+        text.font_weight = label.font_weight
+        text.font_style = label.font_style
+        text.text_anchor = label.text_anchor
+      end
+
+      def label_font_family
+        return "Arial, sans-serif" if theme.equal?(Theme::Registry.get(:default))
+
+        theme_typography(:font_family) || "Arial, sans-serif"
+      end
+
+      def render_relationship(edge, svg)
+        section = edge.sections.first
+        group = Svg::Group.new.tap { |item| item.id = edge.id }
+        group.children << relationship_stroke(section)
+        append_relationship_arrowheads(group, edge)
+        append_relationship_labels(group, edge)
+        svg << group
+      end
+
+      def relationship_stroke(section)
+        control = section.bend_points.first
+        return relationship_curve(section, control) if control
+
+        relationship_line(section.start_point, section.end_point)
+      end
+
+      def relationship_curve(section, control)
+        start_point = section.start_point
+        end_point = section.end_point
+        Svg::Path.new.tap do |path|
+          path.d = relationship_curve_data(start_point, control, end_point)
+          path.fill = "none"
+          path.stroke = theme_color(:edge_stroke)
+          path.stroke_width = "2"
+        end
+      end
+
+      def relationship_line(start_point, end_point)
+        Svg::Line.new.tap do |line|
+          line.x1 = start_point.x
+          line.y1 = start_point.y
+          line.x2 = end_point.x
+          line.y2 = end_point.y
+          line.stroke = theme_color(:edge_stroke)
+          line.stroke_width = "2"
+        end
+      end
+
+      def arrowhead(points)
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = points
+          polygon.fill = theme_color(:edge_stroke)
+          polygon.stroke = theme_color(:edge_stroke)
+        end
+      end
+
+      def apply_box(rect, node)
+        rect.x = node.x
+        rect.y = node.y
+        rect.width = node.width
+        rect.height = node.height
+      end
+
+      def apply_corner_radius(rect, node)
+        rect.rx = node.corner_radius
+        rect.ry = node.corner_radius
+      end
+
+      def positioned?(node)
+        !node.x.nil? && !node.y.nil?
+      end
+
+      private
+
+      def append_boundary_label(group, node)
+        return if node.labels.empty?
+
+        group.children << label_element(node.labels.first,
+                                        element_colours(node)[:text])
+      end
+
+      def append_element_labels(group, node, colours)
+        node.labels.each do |label|
+          group.children << label_element(label, colours[:text])
+        end
+      end
+
+      def append_relationship_arrowheads(group, edge)
+        edge.arrowheads.each { |points| group.children << arrowhead(points) }
+      end
+
+      def append_relationship_labels(group, edge)
+        edge.labels.each do |label|
+          group.children << label_element(label, theme_color(:label_text))
+        end
+      end
+
+      def relationship_curve_data(start_point, control, end_point)
+        "M#{start_point.x},#{start_point.y} " \
+          "Q#{control.x},#{control.y} #{end_point.x},#{end_point.y}"
+      end
+    end
+  end
+end