etassia 0.1.0

data/lib/etassia/renderer/git_graph.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/git_graph"
+require_relative "../svg/document"
+require_relative "../svg/circle"
+require_relative "../svg/line"
+require_relative "../svg/path"
+require_relative "../svg/text"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed Git-graph geometry.
+    class GitGraph < Base
+      CHERRY_PICK_SATELLITE_RADIUS = 2.75
+      CHERRY_PICK_SATELLITE_X_OFFSETS = [-3, 3].freeze
+      CHERRY_PICK_SATELLITE_Y_OFFSET = 2
+      private_constant :CHERRY_PICK_SATELLITE_RADIUS,
+                       :CHERRY_PICK_SATELLITE_X_OFFSETS,
+                       :CHERRY_PICK_SATELLITE_Y_OFFSET
+
+      # @param scene [Layout::GitGraph::Scene] final canvas geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document_from_layout(scene)
+        render_connections(scene, svg)
+        render_commits(scene, svg)
+        render_labels(scene, svg)
+        svg
+      end
+
+      protected
+
+      # Keep the 0.1.0 protected extension point without duplicating the
+      # document construction owned by Renderer::Base.
+      alias create_document_from_layout create_document
+
+      def render_connections(scene, svg)
+        branch_colours = scene.branches.to_h do |branch|
+          [branch.name, branch.color]
+        end
+        scene.connections.each do |connection|
+          svg << connection_element(connection, branch_colours)
+        end
+      end
+
+      def connection_element(connection, branch_colours)
+        colour = connection_colour(connection, branch_colours)
+        if connection.type == :normal
+          return normal_connection(connection, colour)
+        end
+
+        path_connection(connection, colour)
+      end
+
+      def path_connection(connection, colour)
+        Svg::Path.new.tap do |path|
+          path.d = connection.path
+          path.stroke = colour
+          path.stroke_width = "2"
+          path.fill = "none"
+          path.stroke_dasharray = connection.type == :merge ? "5,3" : "2,4"
+        end
+      end
+
+      def normal_connection(connection, colour)
+        Svg::Line.new(
+          x1: connection.from_x, y1: connection.from_y,
+          x2: connection.to_x, y2: connection.to_y,
+          stroke: colour, stroke_width: "2", fill: "none"
+        )
+      end
+
+      def connection_colour(connection, branch_colours)
+        if connection.type == :cherry_pick
+          return theme_color(:edge_stroke)
+        end
+
+        branch_colours[connection.from_branch] ||
+          branch_colours[connection.to_branch] ||
+          theme_color(:edge_stroke)
+      end
+
+      def render_commits(scene, svg)
+        branch_colours = scene.branches.to_h do |branch|
+          [branch.name, branch.color]
+        end
+        commits_in_paint_order(scene).each do |commit|
+          commit_elements(commit, branch_colours).each do |element|
+            svg << element
+          end
+        end
+      end
+
+      def commits_in_paint_order(scene)
+        return scene.commits unless scene.orientation == "BT"
+
+        scene.commits.sort_by(&:y)
+      end
+
+      def commit_circle(commit, branch_colours)
+        Svg::Circle.new.tap do |circle|
+          circle.cx = commit.x
+          circle.cy = commit.y
+          circle.r = Layout::GitGraph::COMMIT_RADIUS
+          circle.fill = commit_fill(commit, branch_colours)
+          circle.stroke = commit_stroke(commit, branch_colours)
+          circle.stroke_width = "2"
+        end
+      end
+
+      def commit_elements(commit, branch_colours)
+        base = commit_circle(commit, branch_colours)
+        return [base] unless commit.is_cherry_pick
+
+        base.class_name = "commit-cherry-pick"
+        [base, *cherry_pick_satellites(commit)]
+      end
+
+      def cherry_pick_satellites(commit)
+        CHERRY_PICK_SATELLITE_X_OFFSETS.map do |offset|
+          Svg::Circle.new(
+            cx: commit.x + offset,
+            cy: commit.y + CHERRY_PICK_SATELLITE_Y_OFFSET,
+            r: CHERRY_PICK_SATELLITE_RADIUS,
+            fill: "#fff",
+            class_name: "commit-cherry-pick",
+          )
+        end
+      end
+
+      def commit_fill(commit, branch_colours)
+        case commit.type
+        when "HIGHLIGHT" then highlight_fill
+        when "REVERSE" then reverse_fill
+        else standard_commit_fill(commit, branch_colours)
+        end
+      end
+
+      def highlight_fill
+        theme_color(:highlight)
+      end
+
+      def reverse_fill
+        theme_color(:background)
+      end
+
+      def standard_commit_fill(commit, branch_colours)
+        branch_colours[commit.branch] || theme_color(:primary)
+      end
+
+      def commit_stroke(commit, branch_colours)
+        branch_colours[commit.branch] || theme_color(:primary)
+      end
+
+      def render_labels(scene, svg)
+        scene.commits.each do |commit|
+          commit.labels.each { |geometry| svg << commit_label(geometry) }
+        end
+        scene.branches.each do |branch|
+          svg << branch_label(branch.label, branch.color) if branch.label
+        end
+      end
+
+      def commit_label(geometry)
+        Svg::Text.new.tap do |text|
+          apply_label_geometry(text, geometry)
+          text.fill = if geometry.kind == "tag"
+                        theme_color(:accent)
+                      else
+                        theme_color(:label_text)
+                      end
+          text.font_weight = "bold" if geometry.kind == "tag"
+        end
+      end
+
+      def branch_label(geometry, colour)
+        Svg::Text.new.tap do |text|
+          apply_label_geometry(text, geometry)
+          text.fill = colour || theme_color(:primary)
+          text.font_weight = "bold"
+        end
+      end
+
+      def apply_label_geometry(text, geometry)
+        apply_label_transform(text, geometry)
+        apply_label_typography(text, geometry)
+        text.content = geometry.text
+      end
+
+      def apply_label_transform(text, geometry)
+        text.x = geometry.x
+        text.y = geometry.y
+        text.class_name = label_class(geometry)
+        text.transform = label_transform(geometry)
+      end
+
+      def label_class(geometry)
+        return "tag-label" if geometry.kind == "tag"
+
+        "commit-label" if geometry.rotation
+      end
+
+      def apply_label_typography(text, geometry)
+        text.text_anchor = geometry.text_anchor
+        text.font_size = geometry.font_size.to_s
+        text.font_family = theme_typography(:font_family) || "Arial, sans-serif"
+      end
+
+      def label_transform(geometry)
+        transforms = []
+        if geometry.rotation
+          values = [geometry.rotation, geometry.rotation_center_x,
+                    geometry.rotation_center_y]
+          transforms << "rotate(#{values.join(' ')})"
+        end
+        if geometry.translation_x
+          transforms << "translate(#{geometry.translation_x} 0)"
+        end
+        transforms.join(" ") unless transforms.empty?
+      end
+    end
+  end
+end

data/lib/etassia/renderer/info.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/info"
+require_relative "../svg/document"
+require_relative "../svg/text"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed Info geometry.
+    #
+    # Renders a simple informational message box with centered text.
+    #
+    # @example Render an info diagram
+    #   renderer = Info.new
+    #   svg = renderer.render(scene)
+    class Info < Base
+      # Renders an Info Scene to SVG.
+      #
+      # @param scene [Layout::Info::Scene] final canvas and label geometry
+      # @return [Svg::Document] the rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+
+        # Render info text
+        render_info_text(scene, svg)
+
+        svg
+      end
+
+      protected
+
+      def render_info_text(scene, svg)
+        svg << Svg::Text.new.tap do |text|
+          set_info_geometry(text, scene.label)
+          set_info_style(text, scene.label)
+        end
+      end
+
+      def set_info_geometry(text, label)
+        text.x = label.x
+        text.y = label.y
+        text.content = label.text
+        text.text_anchor = label.text_anchor
+      end
+
+      def set_info_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
+      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/kanban.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../layout/kanban"
+require_relative "../svg/document"
+require_relative "../svg/line"
+require_relative "../svg/rect"
+require_relative "../svg/text"
+require_relative "markdown_text"
+
+module Etassia
+  module Renderer
+    # Emits SVG from final, typed Kanban geometry.
+    class Kanban < Base
+      # @param scene [Layout::Kanban::Scene] final Kanban geometry
+      # @return [Svg::Document] rendered SVG document
+      def render(scene)
+        svg = create_document(scene)
+        scene.columns.each { |column| render_column(column, svg) }
+        scene.cards.each { |card| render_card(card, svg) }
+        svg
+      end
+
+      protected
+
+      def render_column(column, svg)
+        svg << box_element(column.background)
+        svg << box_element(column.header)
+        svg << label_element(column.title)
+        render_badge(column, svg) if column.badge
+      end
+
+      def render_badge(column, svg)
+        svg << box_element(column.badge)
+        svg << label_element(column.badge_label)
+      end
+
+      def render_card(card, svg)
+        svg << box_element(card.background)
+        svg << accent_element(card.accent) if card.accent
+        svg << label_element(card.label)
+        card.metadata.each { |label| svg << label_element(label) }
+      end
+
+      def accent_element(accent)
+        Svg::Line.new(
+          x1: accent.x1, y1: accent.y1,
+          x2: accent.x2, y2: accent.y2,
+          stroke: accent.color, stroke_width: "4"
+        )
+      end
+
+      def box_element(box)
+        Svg::Rect.new.tap do |rect|
+          assign_box_geometry(rect, box)
+          apply_box_style(rect, box.style)
+        end
+      end
+
+      def assign_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 apply_box_style(rect, style)
+        case style
+        when "column" then apply_column_style(rect)
+        when "header" then apply_header_style(rect)
+        when "badge" then apply_badge_style(rect)
+        when "card" then apply_card_style(rect)
+        end
+      end
+
+      def apply_column_style(rect)
+        rect.fill = theme_color(:background)
+        rect.stroke = theme_color(:border)
+        rect.stroke_width = "1"
+      end
+
+      def apply_header_style(rect)
+        rect.fill = theme_color(:primary)
+      end
+
+      def apply_badge_style(rect)
+        rect.fill = theme_color(:foreground)
+        rect.opacity = "0.3"
+      end
+
+      def apply_card_style(rect)
+        rect.fill = theme_color(:node_fill)
+        rect.stroke = theme_color(:border)
+        rect.stroke_width = "1"
+      end
+
+      def label_element(label)
+        Svg::Text.new.tap do |text|
+          assign_label_geometry(text, label)
+          apply_label_style(text, label)
+          assign_content(text, label)
+        end
+      end
+
+      def assign_label_geometry(text, label)
+        text.x = label.x
+        text.y = label.y
+        text.text_anchor = label.text_anchor if label.text_anchor
+      end
+
+      def apply_label_style(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.font_weight = label.font_weight if label.font_weight
+      end
+
+      def assign_content(text, label)
+        if label.style == "header"
+          assign_header_content(text, label)
+        elsif label.style == "card"
+          assign_card_content(text, label)
+        else
+          text.content = label.text
+        end
+      end
+
+      def assign_header_content(text, label)
+        lines = Etassia::MarkdownText.parse_lines(label.text)
+        MarkdownText.assign_markdown_text(
+          text, lines, x: label.x, base_font_weight: "bold"
+        )
+      end
+
+      def assign_card_content(text, label)
+        lines = Layout::KanbanCardText.lines(
+          label.text, width: label.wrap_width, font_size: label.font_size
+        )
+        MarkdownText.assign_markdown_text(text, lines, x: label.x)
+      end
+
+      def label_color(style)
+        case style
+        when "header", "badge" then theme_color(:background)
+        when "metadata_label" then theme_color(:secondary)
+        else theme_color(:label_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/line_break_text.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../svg/text"
+require_relative "../svg/tspan"
+
+module Etassia
+  module Renderer
+    # Fills an Svg::Text from label text, turning a raw HTML line break
+    # (<br>, <br/>, <br />) into a new line as mmdc does.
+    module LineBreakText
+      BREAK = %r{<br\s*/?>}i
+
+      module_function
+
+      # @param text [Svg::Text] element to fill
+      # @param raw [String] label text, possibly holding line breaks
+      # @return [Svg::Text] the same element
+      def fill(text, raw)
+        lines = raw.to_s.split(BREAK, -1).map(&:strip)
+        return text.tap { text.content = raw } if lines.one?
+
+        fill_lines(text, lines)
+      end
+
+      # @param text [Svg::Text] element to fill
+      # @param lines [Array<String>] already-split lines, at least two
+      # @param pitch [Numeric, nil] user units between baselines; nil
+      #   leaves the spacing to Svg::Text (1.2 x font size)
+      # @return [Svg::Text] the same element
+      def fill_lines(text, lines, pitch: nil)
+        text.tspans = lines.each_with_index.map do |line, index|
+          line_run(line, text, index, pitch)
+        end
+        text
+      end
+
+      def line_run(line, text, index, pitch)
+        Svg::Tspan.new.tap do |run|
+          run.x = text.x
+          place(run, text, index, pitch)
+          run.content = line
+        end
+      end
+
+      def place(run, text, index, pitch)
+        return unless index.positive?
+
+        if pitch
+          run.y = Svg::Numbers.read(text.y) + (index * pitch)
+        else
+          run.line_shift = 1
+        end
+      end
+    end
+  end
+end

data/lib/etassia/renderer/markdown_text.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "../markdown_text"
+require_relative "../svg/tspan"
+
+module Etassia
+  module Renderer
+    # Renders `Etassia::MarkdownText`-parsed label text onto an `Svg::Text`
+    # element as either plain `content` or `<tspan>` children. The text
+    # parsing itself (`parse_lines`, `truncate_runs`, `Run`) lives in the
+    # layer-neutral `Etassia::MarkdownText` (required above) so
+    # `Layout::Kanban` can size a label without depending on this
+    # renderer-only, `Svg::Tspan`-producing half.
+    module MarkdownText
+      module_function
+
+      # Assigns a markdown-parsed label onto a `Svg::Text` element. A plain
+      # label (no markup, no hard line break) keeps setting `content` — no
+      # `<tspan>` wrapper, same XML shape existing fixtures expect.
+      #
+      # @param text_element [Svg::Text] element to assign onto
+      # @param lines [Array<Array<Etassia::MarkdownText::Run>>] truncated runs
+      #   from `Etassia::MarkdownText.parse_lines`
+      # @param x [Numeric] the label's horizontal anchor
+      # @param base_font_weight [String, nil] passed to `build_markdown_tspans`
+      # @return [void]
+      def assign_markdown_text(text_element, lines, base_font_weight: nil,
+                               **coordinates)
+        x_position = required_x(coordinates)
+        if plain_line?(lines)
+          text_element.content = lines.first.first&.text.to_s
+        else
+          text_element.tspans = build_markdown_tspans(
+            lines, x: x_position, base_font_weight: base_font_weight
+          )
+        end
+      end
+
+      # True when parsing found no markup and no hard line break: a single
+      # line holding at most one run, styled neither bold nor italic.
+      #
+      # @param lines [Array<Array<Etassia::MarkdownText::Run>>]
+      # @return [Boolean]
+      # @api private
+      def plain_line?(lines)
+        return false unless lines.length == 1
+
+        runs = lines.first
+        runs.length <= 1 && runs.none? { |run| run.bold || run.italic }
+      end
+
+      # Builds the <tspan> runs for a markdown-parsed label. Only the FIRST
+      # run of a line after a hard line break needs `x` (reset) and a
+      # `line_shift` (lines below the previous placed run) — every other run
+      # continues the previous one.
+      #
+      # @param lines [Array<Array<Etassia::MarkdownText::Run>>] truncated runs
+      #   from `Etassia::MarkdownText.parse_lines`
+      # @param x [Numeric] the label's horizontal anchor
+      # @param base_font_weight [String, nil] "bold" for a bold-by-default
+      #   `Svg::Text` (e.g. a kanban column header)
+      # @return [Array<Svg::Tspan>]
+      # @api private
+      def build_markdown_tspans(lines, base_font_weight: nil, **coordinates)
+        x_position = required_x(coordinates)
+        pending_lines = 0
+        lines.each_with_index.flat_map do |runs, line_index|
+          pending_lines += 1 if line_index.positive?
+          tspans = line_tspans(runs, x_position, pending_lines,
+                               base_font_weight)
+          pending_lines = 0 unless runs.empty?
+          tspans
+        end
+      end
+
+      def required_x(coordinates)
+        return coordinates[:x] if coordinates.key?(:x)
+
+        raise ArgumentError, "missing keyword: :x"
+      end
+
+      def line_tspans(runs, x_position, line_shift, base_font_weight)
+        runs.map.with_index do |run, index|
+          build_tspan(run, x_position, line_shift, base_font_weight,
+                      new_line: index.zero? && line_shift.positive?)
+        end
+      end
+
+      def build_tspan(run, x_position, line_shift, base_font_weight, new_line:)
+        Svg::Tspan.new.tap do |tspan|
+          apply_line_shift(tspan, x_position, line_shift) if new_line
+          if run.bold || base_font_weight == "bold"
+            tspan.font_weight = "bold"
+          end
+          tspan.font_style = "italic" if run.italic
+          tspan.content = run.text
+        end
+      end
+
+      def apply_line_shift(tspan, x_position, line_shift)
+        tspan.x = x_position
+        tspan.line_shift = line_shift
+      end
+    end
+  end
+end