etassia 0.1.0

data/lib/etassia/renderer/mindmap.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../svg/document"
+require_relative "../svg/circle"
+require_relative "../svg/rect"
+require_relative "../svg/path"
+require_relative "../svg/line"
+require_relative "../svg/text"
+require_relative "../svg/tspan"
+require_relative "../svg/group"
+require_relative "../svg/polygon"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed mindmap geometry.
+    class Mindmap < Base
+      # mmdc's class on every node group.
+      NODE_CLASS = "node mindmap-node"
+
+      # @param scene [Layout::Mindmap::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        render_connections(scene, svg)
+        render_nodes(scene, svg)
+
+        svg
+      end
+
+      protected
+
+      # Renders all connections between nodes.
+      #
+      # @param scene [Layout::Mindmap::Scene] final canvas geometry
+      # @param svg [Svg::Document] SVG document
+      # @return [void]
+      def render_connections(scene, svg)
+        scene.edges.each { |edge| render_connection(edge, svg) }
+      end
+
+      # Renders a single connection line.
+      #
+      # @param edge [Layout::Mindmap::Edge] connection geometry
+      # @param svg [Svg::Document] SVG document
+      # @return [void]
+      def render_connection(edge, svg)
+        path = Svg::Path.new.tap do |p|
+          p.d = edge.path
+          p.stroke = level_color(edge.colour_level)
+          p.stroke_width = "2"
+          p.fill = "none"
+        end
+
+        svg.add_element(path)
+      end
+
+      # Renders all nodes with their shapes.
+      #
+      # @param scene [Layout::Mindmap::Scene] final canvas geometry
+      # @param svg [Svg::Document] SVG document
+      # @return [void]
+      def render_nodes(scene, svg)
+        scene.children.each { |node| render_node(node, svg) }
+      end
+
+      # Renders a single node with appropriate shape.
+      #
+      # @param node [Layout::Mindmap::Node] node geometry
+      # @param svg [Svg::Document] SVG document
+      # @return [void]
+      def render_node(node, svg)
+        group = Svg::Group.new.tap { |item| item.class_name = NODE_CLASS }
+        render_shape(node, group)
+        svg.add_element(group)
+      end
+
+      def render_shape(node, group)
+        shape_renderer = case node.shape
+                         when "circle" then :render_circle_node
+                         when "cloud" then :render_cloud_node
+                         when "bang" then :render_bang_node
+                         when "hexagon" then :render_hexagon_node
+                         when "square" then :render_square_node
+                         else :render_default_node
+                         end
+        send(shape_renderer, node, group)
+      end
+
+      # Renders a default rounded rectangle node.
+      #
+      # @param node [Hash] node data
+      # @param x [Numeric] X position
+      # @param y [Numeric] Y position
+      # @param group [Svg::Group] the node's group
+      # @return [void]
+      def render_default_node(node, group)
+        color = level_color(node.level)
+        rect = node_rectangle(node)
+        rect.rx = 5
+        rect.ry = 5
+        paint_node_shape(rect, color)
+        group.add_child(rect)
+        render_node_text(node, group)
+      end
+
+      # Renders a circle node.
+      #
+      # @param node [Hash] node data
+      # @param x [Numeric] X position
+      # @param y [Numeric] Y position
+      # @param group [Svg::Group] the node's group
+      # @return [void]
+      def render_circle_node(node, group)
+        color = level_color(node.level)
+        circle = Svg::Circle.new.tap do |shape|
+          shape.cx = node.center_x
+          shape.cy = node.center_y
+          shape.r = node.radius
+        end
+        paint_node_shape(circle, color)
+        group.add_child(circle)
+        render_node_text(node, group)
+      end
+
+      # Renders a square node.
+      #
+      # @param node [Hash] node data
+      # @param x [Numeric] X position
+      # @param y [Numeric] Y position
+      # @param group [Svg::Group] the node's group
+      # @return [void]
+      def render_square_node(node, group)
+        color = level_color(node.level)
+        rect = node_rectangle(node)
+        paint_node_shape(rect, color)
+        group.add_child(rect)
+        render_node_text(node, group)
+      end
+
+      # Renders a hexagon node.
+      #
+      # @param node [Hash] node data
+      # @param x [Numeric] X position
+      # @param y [Numeric] Y position
+      # @param group [Svg::Group] the node's group
+      # @return [void]
+      def render_hexagon_node(node, group)
+        color = level_color(node.level)
+        polygon = Svg::Polygon.new.tap do |p|
+          p.points = node.shape_points
+          p.fill = lighten_color(color, 0.9)
+          p.stroke = color
+          p.stroke_width = "2"
+        end
+
+        group.add_child(polygon)
+
+        render_node_text(node, group)
+      end
+
+      # Renders a cloud node.
+      #
+      # @param node [Hash] node data
+      # @param x [Numeric] X position
+      # @param y [Numeric] Y position
+      # @param group [Svg::Group] the node's group
+      # @return [void]
+      def render_cloud_node(node, group)
+        color = level_color(node.level)
+        path = Svg::Path.new.tap do |p|
+          p.d = node.shape_path
+          p.fill = lighten_color(color, 0.9)
+          p.stroke = color
+          p.stroke_width = "2"
+        end
+
+        group.add_child(path)
+
+        render_node_text(node, group)
+      end
+
+      # Renders a bang node (cloud with emphasis).
+      #
+      # @param node [Hash] node data
+      # @param x [Numeric] X position
+      # @param y [Numeric] Y position
+      # @param group [Svg::Group] the node's group
+      # @return [void]
+      def render_bang_node(node, group)
+        render_cloud_node(node, group)
+      end
+
+      # Renders text content for a node.
+      #
+      # @param node [Layout::Mindmap::Node] node geometry
+      # @param group [Svg::Group] the node's group
+      # @return [void]
+      def render_node_text(node, group)
+        label = node.labels.first
+        return unless label&.text
+
+        text = node_label(label)
+        fill_lines(text, label)
+        group.add_child(text)
+      end
+
+      # One tspan per line. A line that is followed by another ends in a
+      # space, so the label still reads as one sentence.
+      def fill_lines(text, label)
+        if label.lines.one?
+          return text.tap { text.content = label.lines.first.text }
+        end
+
+        text.tspans = label.lines.each_with_index.map do |line, index|
+          label_run(line, first: index.zero?)
+        end
+      end
+
+      def label_run(line, first:)
+        Svg::Tspan.new.tap do |run|
+          run.content = line.text
+          run.x = line.x
+          run.y = line.y unless first
+        end
+      end
+
+      # Gets the color for a level.
+      # @param level [Integer] depth in the tree
+      # @return [String] color value
+      def level_color(level)
+        colors = theme&.colors
+        palette = colors&.mindmap_palette
+        colors = Theme::Registry.get(:default).colors if palette.nil? ||
+          palette.empty?
+        colors.palette(:mindmap, level || 0)
+      end
+
+      # Lightens a color by a given factor.
+      #
+      # @param color [String] hex color
+      # @param factor [Float] lightening factor (0-1)
+      # @return [String] lightened hex color
+      def lighten_color(color, factor)
+        color = color.sub(/^#/, "")
+        red = lighten_channel(color[0..1].to_i(16), factor)
+        green = lighten_channel(color[2..3].to_i(16), factor)
+        blue = lighten_channel(color[4..5].to_i(16), factor)
+        format("#%<red>02x%<green>02x%<blue>02x",
+               red: red, green: green, blue: blue)
+      end
+
+      private
+
+      def node_rectangle(node)
+        Svg::Rect.new.tap do |rect|
+          rect.x = node.x
+          rect.y = node.y
+          rect.width = node.width
+          rect.height = node.height
+        end
+      end
+
+      def paint_node_shape(shape, color)
+        shape.fill = lighten_color(color, 0.9)
+        shape.stroke = color
+        shape.stroke_width = "2"
+      end
+
+      def node_label(label)
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.y
+          text.text_anchor = "middle"
+          text.fill = theme_color(:label_text)
+          node_label_font(text, label)
+        end
+      end
+
+      def node_label_font(text, label)
+        text.font_size = (label.font_size || 12).to_s
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+      end
+
+      def lighten_channel(channel, factor)
+        (channel + ((255 - channel) * factor)).round
+      end
+    end
+  end
+end

data/lib/etassia/renderer/packet.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/packet"
+require_relative "../svg/document"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "../svg/group"
+
+module Etassia
+  module Renderer
+    # Renders a Packet Diagram scene to SVG the way mermaid draws it: one
+    # filled block per field segment, its label centred, the start and end
+    # bit numbers above it, and the title below the last row.
+    #
+    # @example Render a packet diagram
+    #   renderer = Renderer::Packet.new(theme: my_theme)
+    #   svg = renderer.render(layout)
+    class Packet < Base
+      # Renders the layout structure to SVG.
+      #
+      # @param scene [Layout::Packet::Scene] final packet geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        scene.fields.each { |field| render_typed_field(field, svg) }
+        svg << label_element(scene.title) if scene.title
+        svg
+      end
+
+      protected
+
+      def render_typed_field(field, svg)
+        svg << field_box(field.box)
+        svg << label_element(field.label)
+        svg << label_element(field.start_label)
+        svg << label_element(field.end_label) if field.end_label
+      end
+
+      def field_box(box)
+        Svg::Rect.new.tap do |rect|
+          set_field_geometry(rect, box)
+          rect.fill = theme_color(:field_background)
+          rect.stroke = theme_color(:field_border)
+          rect.stroke_width = "1"
+        end
+      end
+
+      def label_element(label)
+        Svg::Text.new.tap do |text|
+          set_label_geometry(text, label)
+          text.fill = label_color(label.style)
+          text.font_size = number_string(label.font_size)
+          text.font_family = theme_typography(:font_family) ||
+            "Arial, sans-serif"
+          text.content = label.text
+        end
+      end
+
+      def set_field_geometry(rect, box)
+        rect.x = box.x
+        rect.y = box.y
+        rect.width = box.width
+        rect.height = box.height
+      end
+
+      def set_label_geometry(text, label)
+        text.x = label.x
+        text.y = label.y
+        text.text_anchor = label.text_anchor
+        text.dominant_baseline = label.dominant_baseline
+      end
+
+      def label_color(style)
+        case style
+        when "title" then theme_color(:title_text)
+        when "start", "end" then theme_color(:label_text)
+        else theme_color(:field_text)
+        end
+      end
+
+      def number_string(value)
+        value.to_i == value ? value.to_i.to_s : value.to_s
+      end
+    end
+  end
+end

data/lib/etassia/renderer/pie.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/pie"
+require_relative "../svg/document"
+require_relative "../svg/circle"
+require_relative "../svg/path"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "../svg/group"
+
+module Etassia
+  module Renderer
+    # Pie chart renderer for converting pie diagrams to SVG.
+    #
+    # Converts a Pie diagram model into SVG with calculated slice angles,
+    # colors from theme, labels, and optional data values.
+    #
+    # @example Render a pie chart
+    #   renderer = Pie.new
+    #   svg = renderer.render(pie_diagram)
+    class Pie < Base
+      # Renders a pie chart diagram to SVG.
+      #
+      # @param scene [Layout::Pie::Scene] final pie geometry
+      # @return [Svg::Document] the rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        svg << outer_circle(scene.ring)
+        svg << typed_label(scene.title) if scene.title
+        scene.slices.each { |slice| add_slice(svg, slice) }
+        scene.legend.each { |entry| add_legend_entry(svg, entry) }
+        svg
+      end
+
+      protected
+
+      def outer_circle(ring)
+        Svg::Circle.new(
+          cx: ring.cx, cy: ring.cy, r: ring.radius,
+          fill: "none", stroke_width: "2",
+          stroke: theme_color(:label_text)
+        )
+      end
+
+      def add_slice(svg, slice)
+        svg << typed_slice(slice)
+        svg << typed_label(slice.label)
+      end
+
+      def typed_slice(slice)
+        Svg::Path.new.tap do |path|
+          path.d = slice.path
+          path.fill = get_slice_color(slice.color_index)
+          path.stroke = theme_color(:node_stroke)
+          path.stroke_width = "2"
+          path.id = slice.id.sub("_", "-")
+        end
+      end
+
+      def add_legend_entry(svg, entry)
+        color = get_slice_color(entry.color_index)
+        svg << Svg::Rect.new(x: entry.x, y: entry.y,
+                             width: entry.width, height: entry.height,
+                             fill: color, stroke: color)
+        svg << legend_text(entry)
+      end
+
+      def legend_text(entry)
+        Svg::Text.new.tap do |text|
+          text.x = entry.text_x
+          text.y = entry.text_y
+          text.content = entry.text
+          apply_text_theme(text, entry.font_size)
+        end
+      end
+
+      def apply_text_theme(text, font_size)
+        text.fill = theme_color(:label_text)
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = number_string(font_size)
+      end
+
+      def typed_label(label)
+        Svg::Text.new.tap do |text|
+          set_label_geometry(text, label)
+          set_label_style(text, label)
+        end
+      end
+
+      def set_label_geometry(text, label)
+        text.x = label.x
+        text.y = label.y
+        text.text_anchor = label.text_anchor
+        text.dominant_baseline = label.dominant_baseline
+      end
+
+      def set_label_style(text, label)
+        text.content = label.text
+        apply_text_theme(text, label.font_size)
+        text.font_weight = label.font_weight if label.font_weight
+      end
+
+      def number_string(value)
+        value.to_i == value ? value.to_i.to_s : value.to_s
+      end
+
+      def get_slice_color(index)
+        theme.colors.palette(:pie, index)
+      end
+    end
+  end
+end

data/lib/etassia/renderer/quadrant.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/quadrant"
+require_relative "../svg/document"
+require_relative "../svg/rect"
+require_relative "../svg/line"
+require_relative "../svg/circle"
+require_relative "../svg/group"
+require_relative "../svg/text"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed quadrant-chart geometry.
+    class Quadrant < Base
+      # @param scene [Layout::Quadrant::Scene] final chart geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        scene_groups(scene).each { |element| svg << element }
+        svg
+      end
+
+      protected
+
+      def scene_groups(scene)
+        [quadrants_group(scene), border_group(scene.axes),
+         points_group(scene.points), labels_group(scene.axis_labels),
+         title_group(scene.title)]
+      end
+
+      def group(name)
+        Svg::Group.new(class_name: name)
+      end
+
+      # One `g.quadrant` per region: its rect, then its label when written.
+      def quadrants_group(scene)
+        group("quadrants").tap do |quadrants|
+          scene.quadrants.each do |quadrant|
+            quadrants << quadrant_group(quadrant)
+          end
+        end
+      end
+
+      def quadrant_group(quadrant)
+        group("quadrant").tap do |cell|
+          cell << quadrant_rect(quadrant)
+          cell << text_element(quadrant.label) if quadrant.label
+        end
+      end
+
+      def quadrant_rect(quadrant)
+        Svg::Rect.new.tap do |rect|
+          rect.x = quadrant.x
+          rect.y = quadrant.y
+          rect.width = quadrant.width
+          rect.height = quadrant.height
+          rect.fill = quadrant_color(quadrant.number)
+        end
+      end
+
+      def border_group(lines)
+        group("border").tap do |border|
+          lines.each { |line| border << border_line(line) }
+        end
+      end
+
+      def border_line(line)
+        Svg::Line.new.tap do |element|
+          element.x1 = line.x1
+          element.y1 = line.y1
+          element.x2 = line.x2
+          element.y2 = line.y2
+          apply_border_style(element, line.stroke_width)
+        end
+      end
+
+      def apply_border_style(element, width)
+        element.stroke = theme_color(:quadrant_grid_line)
+        element.stroke_width = number_string(width)
+      end
+
+      def points_group(points)
+        group("data-points").tap do |container|
+          points.each { |point| container << point_group(point) }
+        end
+      end
+
+      def point_group(point)
+        group("data-point").tap do |cell|
+          cell << point_element(point)
+          cell << text_element(point.label)
+        end
+      end
+
+      def labels_group(labels)
+        group("labels").tap do |container|
+          labels.each { |label| container << label_group(label) }
+        end
+      end
+
+      def label_group(label)
+        group("label").tap { |cell| cell << text_element(label) }
+      end
+
+      def title_group(title)
+        group("title").tap do |container|
+          container << text_element(title) if title
+        end
+      end
+
+      def point_element(point)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = point.x
+          circle.cy = point.y
+          circle.r = point.radius
+          apply_point_style(circle, point)
+        end
+      end
+
+      def apply_point_style(circle, point)
+        circle.fill = point.color || point_color(point.quadrant)
+        circle.stroke = point_stroke(point)
+        circle.stroke_width = number_string(point.stroke_width)
+        circle.id = point.id
+      end
+
+      def point_stroke(point)
+        point.stroke_color || theme_color(:node_stroke)
+      end
+
+      # Scene labels already carry final canvas coordinates. A rotated label
+      # turns around its own anchor instead of moving from a local origin.
+      def text_element(label)
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.y
+          text.content = label.text
+          text.transform = rotation_transform(label)
+          apply_text_alignment(text, label)
+          apply_text_style(text, label)
+        end
+      end
+
+      def apply_text_alignment(text, label)
+        text.dominant_baseline = label.baseline
+        text.text_anchor = label.text_anchor if label.text_anchor
+      end
+
+      def rotation_transform(label)
+        return if label.rotation.nil? || label.rotation.zero?
+
+        values = [label.rotation, label.x, label.y].map do |value|
+          number_string(value)
+        end
+        "rotate(#{values.join(' ')})"
+      end
+
+      def apply_text_style(text, label)
+        text.fill = theme_color(:label_text)
+        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 quadrant_color(number)
+        colors = theme&.colors
+        palette = colors&.quadrant_palette
+        colors = Theme::Registry.get(:default).colors if palette.nil? ||
+          palette.empty?
+        colors.palette(:quadrant, number - 1)
+      end
+
+      def point_color(number)
+        {
+          1 => theme_color(:primary),
+          2 => theme_color(:secondary),
+          3 => theme_color(:accent),
+          4 => theme_color(:success),
+        }.fetch(number, theme_color(:primary))
+      end
+
+      def number_string(value)
+        value = value.to_f.round(4)
+        value.to_i == value ? value.to_i.to_s : value.to_s
+      end
+    end
+  end
+end