etassia 0.1.0

data/lib/etassia/renderer/radar.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/radar"
+require_relative "../svg/document"
+require_relative "../svg/circle"
+require_relative "../svg/line"
+require_relative "../svg/path"
+require_relative "../svg/polygon"
+require_relative "../svg/text"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed radar-chart geometry.
+    class Radar < Base
+      # @param scene [Layout::Radar::Scene, Hash] final geometry or released
+      #   positioned-Hash input
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        scene = typed_scene(scene)
+        svg = create_document(scene)
+        render_grid(scene, svg)
+        scene.curves.each { |curve| render_curve(curve, svg, scene) }
+        scene.legend.each { |entry| render_legend(entry, svg) }
+        svg << label_element(scene.title) if scene.title
+        svg
+      end
+
+      protected
+
+      def typed_scene(scene)
+        return scene if scene.is_a?(Layout::Radar::Scene)
+
+        Layout::Radar.from_graph(scene, theme: theme)
+      end
+
+      def grid_ring(ring, scene)
+        return grid_circle(ring) unless scene.grid_shape == "polygon"
+
+        grid_polygon(ring)
+      end
+
+      def grid_polygon(ring)
+        Svg::Polygon.new.tap do |element|
+          element.points = ring.polygon_points
+          style_ring(element)
+        end
+      end
+
+      def grid_circle(circle)
+        Svg::Circle.new.tap do |element|
+          element.cx = circle.x
+          element.cy = circle.y
+          element.r = circle.radius
+          style_ring(element)
+        end
+      end
+
+      def style_ring(element)
+        element.fill = "none"
+        element.stroke = theme_color(:radar_grid_line)
+        element.stroke_width = "1"
+        element.class_name = "radarGraticule"
+      end
+
+      def render_axis(axis, svg)
+        svg << axis_line(axis.line)
+        svg << label_element(axis.label)
+      end
+
+      def render_curve(curve, svg, scene)
+        return if curve.points.empty?
+
+        color = curve_color(curve.color_index)
+        svg << curve_shape(curve, color, scene)
+        curve.points.each { |point| svg << point_element(point, color) }
+      end
+
+      def curve_shape(curve, color, scene)
+        return curve_path(curve, color) unless scene.grid_shape == "polygon"
+
+        curve_polygon(curve, color)
+      end
+
+      def curve_polygon(curve, color)
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = curve.polygon_points
+          paint_curve(polygon, curve, color)
+        end
+      end
+
+      def curve_path(curve, color)
+        Svg::Path.new.tap do |path|
+          path.d = curve.path_data
+          paint_curve(path, curve, color)
+        end
+      end
+
+      def paint_curve(shape, curve, color)
+        shape.class_name = "radarCurve-#{curve.color_index}"
+        shape.fill = color
+        shape.fill_opacity = "0.3"
+        shape.stroke = color
+        shape.stroke_width = "2"
+      end
+
+      def point_element(point, color)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = point.x
+          circle.cy = point.y
+          circle.r = point.radius
+          circle.fill = color
+          circle.stroke = theme_color(:background)
+          circle.stroke_width = "1"
+        end
+      end
+
+      def render_legend(entry, svg)
+        svg << legend_marker(entry.marker, curve_color(entry.color_index))
+        svg << label_element(entry.label)
+      end
+
+      def label_element(label)
+        Svg::Text.new.tap do |text|
+          text.x = label.x
+          text.y = label.y
+          style_label(text, label)
+          text.content = label.text
+        end
+      end
+
+      def curve_color(index)
+        theme.colors.palette(:radar, index)
+      end
+
+      def number_string(value)
+        value.to_i == value ? value.to_i.to_s : value.to_s
+      end
+
+      private
+
+      def render_grid(scene, svg)
+        scene.grid_circles.each { |ring| svg << grid_ring(ring, scene) }
+        scene.axes.each { |axis| render_axis(axis, svg) }
+      end
+
+      def axis_line(geometry)
+        Svg::Line.new.tap do |line|
+          line.x1 = geometry.x1
+          line.y1 = geometry.y1
+          line.x2 = geometry.x2
+          line.y2 = geometry.y2
+          style_axis_line(line)
+        end
+      end
+
+      def style_axis_line(line)
+        line.stroke = theme_color(:radar_axis_line)
+        line.stroke_width = "1"
+        line.class_name = "radarAxisLine"
+      end
+
+      def legend_marker(marker, color)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = marker.x
+          circle.cy = marker.y
+          circle.r = marker.radius
+          circle.fill = color
+          circle.stroke = "none"
+        end
+      end
+
+      def style_label(text, label)
+        text.text_anchor = label.text_anchor
+        text.fill = theme_color(:label_text)
+        apply_label_typography(text, label)
+        text.class_name = label.class_name
+      end
+
+      def apply_label_typography(text, label)
+        text.font_size = number_string(label.font_size)
+        text.font_family = label_font_family
+        text.font_weight = label.font_weight if label.font_weight
+      end
+
+      def label_font_family
+        theme_typography(:font_family) || "Arial, sans-serif"
+      end
+    end
+  end
+end

data/lib/etassia/renderer/requirement.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/requirement"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed requirement geometry.
+    class Requirement < Base
+      RISK_LEVELS = %w[high medium low].freeze
+      private_constant :RISK_LEVELS
+
+      REQUIREMENT_TYPE_LABELS = Layout::Requirement::REQUIREMENT_TYPE_LABELS
+
+      # @param scene [Layout::Requirement::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        scene.edges.each { |edge| render_relationship(edge, svg) }
+        scene.children.each { |node| render_node(node, svg) }
+        svg
+      end
+
+      protected
+
+      def render_node(node, svg)
+        if node.kind == "requirement"
+          render_requirement(node, svg)
+        else
+          render_element(node, svg)
+        end
+      end
+
+      def render_requirement(node, svg)
+        children = [requirement_box(node), requirement_header(node)]
+        children.concat(requirement_body_labels(node))
+        svg << group_with_children("requirement-#{node.id}", children)
+      end
+
+      def requirement_body_labels(node)
+        node.labels.reject { |label| label.role == "header" }.map do |label|
+          requirement_label(label, node.risk)
+        end
+      end
+
+      def requirement_box(node)
+        Svg::Rect.new.tap do |rect|
+          apply_rect(rect, node.box)
+          rect.fill = theme_color(:node_fill)
+          rect.stroke = risk_color(node.risk) ||
+            theme_color(:requirement_box_border)
+          rect.stroke_width = "2"
+          rect.rx = "5"
+          rect.ry = "5"
+        end
+      end
+
+      def requirement_header(node)
+        children = [requirement_header_background(node)]
+        children.concat(
+          node.labels.select { |label| label.role == "header" }.map do |label|
+            header_label(label)
+          end,
+        )
+        group_with_children(nil, children)
+      end
+
+      def requirement_header_background(node)
+        Svg::Rect.new.tap do |rect|
+          apply_rect(rect, node.header)
+          rect.fill = risk_color(node.risk) || theme_color(:node_fill)
+          rect.opacity = "0.3"
+        end
+      end
+
+      def header_label(label)
+        Svg::Text.new.tap do |text|
+          apply_label(text, label)
+          text.fill = theme_color(:requirement_text)
+          text.dominant_baseline = "middle"
+        end
+      end
+
+      def requirement_label(label, risk)
+        Svg::Text.new.tap do |text|
+          apply_label(text, label)
+          text.fill = if label.role == "risk"
+                        risk_color(risk)
+                      else
+                        theme_color(:requirement_text)
+                      end
+        end
+      end
+
+      def render_element(node, svg)
+        children = [element_shape(node)]
+        children.concat(node.labels.map { |label| element_label(label) })
+        svg << group_with_children("element-#{node.id}", children)
+      end
+
+      def element_shape(node)
+        Svg::Polygon.new.tap do |polygon|
+          polygon.points = node.shape_points
+          polygon.fill = theme_color(:node_fill)
+          polygon.stroke = theme_color(:requirement_element_border)
+          polygon.stroke_width = "2"
+        end
+      end
+
+      def element_label(label)
+        Svg::Text.new.tap do |text|
+          apply_label(text, label)
+          text.fill = if label.role == "detail"
+                        theme_color(:requirement_detail_text)
+                      else
+                        theme_color(:requirement_text)
+                      end
+          text.dominant_baseline = "middle"
+        end
+      end
+
+      def render_relationship(edge, svg)
+        children = [relationship_path(edge)]
+        children.concat(relationship_label_elements(edge))
+        id = "relationship-#{edge.source}-#{edge.target}"
+        svg << group_with_children(id, children)
+      end
+
+      def relationship_path(edge)
+        Svg::Path.new.tap do |path|
+          path.d = edge.path
+          path.fill = "none"
+          path.stroke = theme_color(:edge_color)
+          path.stroke_width = "2"
+          path.marker_end = "url(#arrowhead)"
+        end
+      end
+
+      def relationship_label_elements(edge)
+        return [] if edge.labels.empty?
+
+        [
+          relationship_label_background(edge),
+          relationship_label(edge.labels.first),
+        ]
+      end
+
+      def relationship_label_background(edge)
+        Svg::Rect.new.tap do |rect|
+          apply_rect(rect, edge.label_background)
+          rect.fill = "#fff"
+          rect.stroke = theme_color(:edge_color)
+          rect.stroke_width = "1"
+          rect.rx = "3"
+        end
+      end
+
+      def relationship_label(label)
+        Svg::Text.new.tap do |text|
+          apply_label(text, label)
+          text.fill = theme_color(:requirement_text)
+          text.dominant_baseline = "middle"
+        end
+      end
+
+      def group_with_children(id, children)
+        Svg::Group.new.tap do |group|
+          group.id = id if id
+          group.children.concat(children)
+        end
+      end
+
+      def apply_rect(rect, geometry)
+        rect.x = geometry.x
+        rect.y = geometry.y
+        rect.width = geometry.width
+        rect.height = geometry.height
+      end
+
+      def apply_label(text, label)
+        text.x = label.x
+        text.y = label.y
+        text.content = label.text
+        text.font_size = label.font_size.to_s
+        text.font_weight = label.font_weight
+        text.text_anchor = label.text_anchor
+      end
+
+      def risk_color(risk)
+        return unless risk
+
+        index = RISK_LEVELS.index(risk.downcase)
+        return theme_color(:requirement_unknown_risk_border) unless index
+
+        risk_palette_colors.palette(:requirement_risk, index)
+      end
+
+      private
+
+      def risk_palette_colors
+        colors = theme&.colors
+        palette = colors&.requirement_risk_palette
+        colors = Theme::Registry.get(:default).colors if palette.nil? ||
+          palette.empty?
+        colors
+      end
+    end
+  end
+end

data/lib/etassia/renderer/sankey.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/sankey"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed Sankey geometry.
+    class Sankey < Base
+      # @param scene [Layout::Sankey::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        render_title(scene.title, svg) if scene.title
+        scene.flows.each { |flow| render_flow(flow, svg) unless flow.self_loop }
+        scene.nodes.each { |node| render_node(node, svg) }
+        svg
+      end
+
+      protected
+
+      def render_title(title, svg)
+        svg << Svg::Text.new.tap do |text|
+          assign_text_geometry(text, title)
+          apply_title_style(text)
+        end
+      end
+
+      def assign_text_geometry(text, label)
+        text.x = label.x
+        text.y = label.y
+        text.content = label.text
+      end
+
+      def apply_title_style(text)
+        text.fill = theme_color(:label_text)
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = (theme_typography(:font_size_large) || 18).to_s
+        text.text_anchor = "middle"
+        text.font_weight = "bold"
+      end
+
+      def render_node(node, svg)
+        svg << node_rectangle(node)
+        svg << node_label(node.label)
+      end
+
+      def node_rectangle(node)
+        Svg::Rect.new.tap do |rect|
+          assign_node_geometry(rect, node)
+          apply_node_style(rect)
+        end
+      end
+
+      def assign_node_geometry(rect, node)
+        rect.x = node.x
+        rect.y = node.y
+        rect.width = node.width
+        rect.height = node.height
+        rect.rx = node.corner_radius
+        rect.ry = node.corner_radius
+      end
+
+      def apply_node_style(rect)
+        rect.fill = theme_color(:node_fill)
+        rect.stroke = theme_color(:node_stroke)
+        rect.stroke_width = "2"
+      end
+
+      def node_label(label)
+        Svg::Text.new.tap do |text|
+          assign_text_geometry(text, label)
+          apply_node_label_style(text)
+        end
+      end
+
+      def apply_node_label_style(text)
+        text.fill = theme_color(:node_text)
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = (theme_typography(:font_size_small) || 11).to_s
+        text.text_anchor = "middle"
+        text.font_weight = "bold"
+      end
+
+      def render_flow(flow, svg)
+        svg << Svg::Path.new.tap do |path|
+          path.d = flow.path
+          path.fill = flow_colour(flow)
+          path.opacity = "0.4"
+          path.stroke = "none"
+        end
+        svg << flow_label(flow.label) if flow.label
+      end
+
+      def flow_label(label)
+        Svg::Text.new.tap do |text|
+          assign_text_geometry(text, label)
+          apply_flow_label_style(text)
+        end
+      end
+
+      def apply_flow_label_style(text)
+        text.fill = theme_color(:label_text)
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+        text.font_size = (theme_typography(:font_size_small) || 10).to_s
+        text.text_anchor = "middle"
+      end
+
+      def flow_colour(flow)
+        theme.colors.palette(:flow, flow.colour_index)
+      end
+    end
+  end
+end

data/lib/etassia/renderer/sequence/frame_drawing.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Renderer
+    class Sequence < Base
+      # Draws the control frames and `box` groups of a laid-out sequence
+      # diagram. Boxes go behind everything else; frames go behind the
+      # messages they enclose.
+      module FrameDrawing
+        FRAME_STROKE = "#333333"
+        TAB_FILL = "#eaeaea"
+        DEFAULT_BOX_FILL = "none"
+        DEFAULT_RECT_FILL = "#cccccc"
+
+        private
+
+        def draw_boxes(scene, svg)
+          scene.boxes.each_with_index do |box, index|
+            group = Svg::Group.new.tap { |g| g.id = "box-#{index}" }
+            group.children << box_outline(box)
+            group.children << box_title(box) if box.title
+            svg << group
+          end
+        end
+
+        def box_outline(box)
+          bounds_rect(box).tap do |rect|
+            rect.fill = box.color || DEFAULT_BOX_FILL
+            rect.stroke = theme_color(:node_stroke)
+            rect.stroke_opacity = "0.5"
+            rect.class_name = "box"
+          end
+        end
+
+        def box_title(box)
+          frame_text(box.title, box.title_x, box.title_y, box)
+        end
+
+        def draw_frames(scene, svg)
+          scene.frames.each_with_index do |frame, index|
+            group = Svg::Group.new.tap { |g| g.id = "frame-#{index}" }
+            fill_frame_group(group, frame)
+            svg << group
+          end
+        end
+
+        def fill_frame_group(group, frame)
+          if frame.kind == "rect"
+            group.children << rect_frame(frame)
+            return
+          end
+
+          group.children << frame_outline(frame)
+          group.children.concat(frame_tab(frame))
+          group.children.concat(frame_dividers(frame))
+        end
+
+        def rect_frame(frame)
+          bounds_rect(frame).tap do |rect|
+            rect.fill = rect_fill(frame)
+            rect.class_name = "frame-rect"
+          end
+        end
+
+        def rect_fill(frame)
+          return frame.color unless frame.color.to_s.empty?
+
+          default_theme_paint(:disabled_fill, DEFAULT_RECT_FILL)
+        end
+
+        def frame_outline(frame)
+          bounds_rect(frame).tap do |rect|
+            rect.fill = "none"
+            rect.stroke = frame_stroke
+            rect.stroke_width = "2"
+            rect.class_name = "frame-outline"
+          end
+        end
+
+        def bounds_rect(shape)
+          Svg::Rect.new.tap do |rect|
+            rect.x = shape.x
+            rect.y = shape.y
+            rect.width = shape.width
+            rect.height = shape.height
+          end
+        end
+
+        def frame_tab(frame)
+          tab = [frame_tab_polygon(frame),
+                 frame_text(frame.kind, frame.kind_x, frame.kind_y, frame)]
+          return tab unless frame.title
+
+          tab.concat(title_texts(frame))
+        end
+
+        def title_texts(frame)
+          lines = frame.title_lines.empty? ? [frame.title] : frame.title_lines
+          lines.zip(frame.title_ys).map do |line, y|
+            frame_text(line, frame.title_x, y, frame)
+          end
+        end
+
+        def frame_tab_polygon(frame)
+          Svg::Polygon.new.tap do |polygon|
+            polygon.points = frame.tab_points
+            polygon.fill = default_theme_paint(:surface_variant, TAB_FILL)
+            polygon.stroke = frame_stroke
+          end
+        end
+
+        def frame_dividers(frame)
+          frame.dividers.flat_map do |divider|
+            [divider_line(divider),
+             frame_text(divider.text, divider.text_x, divider.text_y, frame)]
+          end
+        end
+
+        def divider_line(divider)
+          Svg::Line.new.tap do |line|
+            line.x1 = divider.x1
+            line.y1 = divider.y
+            line.x2 = divider.x2
+            line.y2 = divider.y
+            style_divider(line)
+          end
+        end
+
+        def style_divider(line)
+          line.stroke = frame_stroke
+          line.stroke_width = "2"
+          line.stroke_dasharray = "3,3"
+        end
+
+        def frame_text(content, horizontal, vertical, shape)
+          Svg::Text.new.tap do |text|
+            text.x = horizontal
+            text.y = vertical
+            text.content = content
+            style_frame_text(text, shape)
+            text.text_anchor = "middle"
+          end
+        end
+
+        def style_frame_text(text, shape)
+          text.fill = theme_color(:label_text)
+          text.font_family = frame_font_family
+          text.font_size = number_string(shape.font_size)
+        end
+
+        def frame_stroke
+          default_theme_paint(:edge_stroke, FRAME_STROKE)
+        end
+
+        def frame_font_family
+          return "Arial, sans-serif" if theme.equal?(Theme::Registry.get(:default))
+
+          theme_typography(:font_family) || "Arial, sans-serif"
+        end
+
+        def default_theme_paint(role, original)
+          return original if theme.equal?(Theme::Registry.get(:default))
+
+          theme_color(role)
+        end
+      end
+    end
+  end
+end