sirena 0.1.0

data/lib/sirena/transform/kanban.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Transform
+    # Transforms a Kanban diagram into a positioned layout structure.
+    #
+    # The layout algorithm handles:
+    # - Columns positioned horizontally
+    # - Cards stacked vertically within columns
+    # - Proper spacing and sizing
+    #
+    # @example Transform a kanban board
+    #   transform = Transform::Kanban.new
+    #   layout = transform.to_graph(diagram)
+    class Kanban
+      # Horizontal spacing between columns
+      COLUMN_HORIZONTAL_SPACING = 60
+
+      # Vertical spacing between cards
+      CARD_VERTICAL_SPACING = 15
+
+      # Column dimensions
+      COLUMN_WIDTH = 200
+      COLUMN_HEADER_HEIGHT = 50
+      COLUMN_PADDING = 10
+
+      # Card dimensions
+      CARD_HEIGHT = 80
+      CARD_PADDING = 10
+
+      # Metadata display height per item
+      METADATA_LINE_HEIGHT = 18
+
+      # Transforms the diagram into a layout structure.
+      #
+      # @param diagram [Diagram::Kanban] the kanban diagram
+      # @return [Hash] layout data with columns, cards, and dimensions
+      def to_graph(diagram)
+        return empty_graph if diagram.columns.empty?
+
+        # Position columns horizontally
+        positioned_columns = position_columns(diagram.columns)
+
+        # Position cards within each column
+        positioned_cards = position_cards(positioned_columns)
+
+        # Calculate overall bounds
+        bounds = calculate_bounds(positioned_columns, positioned_cards)
+
+        {
+          columns: positioned_columns,
+          cards: positioned_cards,
+          width: bounds[:width],
+          height: bounds[:height]
+        }
+      end
+
+      private
+
+      def empty_graph
+        {
+          columns: [],
+          cards: [],
+          width: 0,
+          height: 0
+        }
+      end
+
+      # Positions columns horizontally
+      #
+      # @param columns [Array<Diagram::KanbanColumn>] columns to position
+      # @return [Array<Hash>] positioned columns
+      def position_columns(columns)
+        positioned = []
+        current_x = 0
+
+        columns.each do |column|
+          positioned << {
+            id: column.id,
+            title: column.title,
+            x: current_x,
+            y: 0,
+            width: COLUMN_WIDTH,
+            height: calculate_column_height(column),
+            card_count: column.cards.size,
+            original: column
+          }
+
+          current_x += COLUMN_WIDTH + COLUMN_HORIZONTAL_SPACING
+        end
+
+        positioned
+      end
+
+      # Positions cards within their columns
+      #
+      # @param positioned_columns [Array<Hash>] positioned columns
+      # @return [Array<Hash>] positioned cards
+      def position_cards(positioned_columns)
+        cards = []
+
+        positioned_columns.each do |column_data|
+          column = column_data[:original]
+          column_x = column_data[:x]
+          current_y = COLUMN_HEADER_HEIGHT + COLUMN_PADDING
+
+          column.cards.each do |card|
+            card_height = calculate_card_height(card)
+
+            cards << {
+              id: card.id,
+              text: card.text,
+              column_id: column.id,
+              x: column_x + COLUMN_PADDING,
+              y: current_y,
+              width: COLUMN_WIDTH - (COLUMN_PADDING * 2),
+              height: card_height,
+              metadata: card.metadata,
+              has_metadata: card.has_metadata?,
+              original: card
+            }
+
+            current_y += card_height + CARD_VERTICAL_SPACING
+          end
+        end
+
+        cards
+      end
+
+      # Calculates the height needed for a column
+      #
+      # @param column [Diagram::KanbanColumn] column
+      # @return [Numeric] column height
+      def calculate_column_height(column)
+        return COLUMN_HEADER_HEIGHT + COLUMN_PADDING if column.cards.empty?
+
+        # Header + padding + sum of card heights + spacing between cards
+        total_card_height = column.cards.sum { |card| calculate_card_height(card) }
+        total_spacing = (column.cards.size - 1) * CARD_VERTICAL_SPACING
+        bottom_padding = COLUMN_PADDING
+
+        COLUMN_HEADER_HEIGHT + COLUMN_PADDING +
+          total_card_height + total_spacing + bottom_padding
+      end
+
+      # Calculates the height needed for a card
+      #
+      # @param card [Diagram::KanbanCard] card
+      # @return [Numeric] card height
+      def calculate_card_height(card)
+        base_height = CARD_HEIGHT
+
+        # Add height for metadata if present
+        if card.has_metadata?
+          metadata_count = card.metadata.size
+          base_height + (metadata_count * METADATA_LINE_HEIGHT)
+        else
+          base_height
+        end
+      end
+
+      # Calculates the bounding box for the entire board
+      #
+      # @param columns [Array<Hash>] positioned columns
+      # @param cards [Array<Hash>] positioned cards
+      # @return [Hash] width and height
+      def calculate_bounds(columns, cards)
+        return { width: 0, height: 0 } if columns.empty?
+
+        max_x = columns.map { |c| c[:x] + c[:width] }.max
+        max_y = columns.map { |c| c[:height] }.max
+
+        {
+          width: max_x,
+          height: max_y
+        }
+      end
+    end
+  end
+end

data/lib/sirena/transform/mindmap.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Transform
+    # Transforms a Mindmap diagram into a positioned layout structure.
+    #
+    # The layout algorithm handles:
+    # - Tree-based layout with root at center
+    # - Radial positioning of branches
+    # - Level-based spacing
+    # - Connection path calculation
+    #
+    # @example Transform a mindmap
+    #   transform = Transform::Mindmap.new
+    #   layout = transform.to_graph(diagram)
+    class Mindmap
+      # Horizontal spacing between sibling nodes
+      NODE_HORIZONTAL_SPACING = 120
+
+      # Vertical spacing between levels
+      LEVEL_VERTICAL_SPACING = 80
+
+      # Default node dimensions
+      DEFAULT_NODE_WIDTH = 100
+      DEFAULT_NODE_HEIGHT = 40
+
+      # Padding for root node
+      ROOT_PADDING = 20
+
+      # Transforms the diagram into a layout structure.
+      #
+      # @param diagram [Diagram::Mindmap] the mindmap diagram
+      # @return [Hash] layout data with nodes and connections
+      def to_graph(diagram)
+        return empty_graph unless diagram.root
+
+        # Position nodes using tree layout
+        positioned_nodes = position_tree(diagram.root)
+
+        # Build connections between nodes
+        connections = build_connections(diagram.root)
+
+        # Calculate bounds
+        bounds = calculate_bounds(positioned_nodes)
+
+        {
+          nodes: positioned_nodes,
+          connections: connections,
+          width: bounds[:width],
+          height: bounds[:height],
+          root: positioned_nodes.first
+        }
+      end
+
+      private
+
+      def empty_graph
+        {
+          nodes: [],
+          connections: [],
+          width: 0,
+          height: 0,
+          root: nil
+        }
+      end
+
+      # Positions nodes in a tree layout
+      #
+      # @param root [Diagram::Mindmap::MindmapNode] root node
+      # @return [Array<Hash>] positioned nodes
+      def position_tree(root)
+        nodes = []
+
+        # Start with root at center-top
+        root_width = estimate_node_width(root)
+        root_height = estimate_node_height(root)
+
+        # Calculate tree width to center root
+        tree_width = calculate_tree_width(root)
+        root_x = tree_width / 2
+
+        # Position root
+        nodes << {
+          id: root.id,
+          content: root.content,
+          x: root_x,
+          y: ROOT_PADDING,
+          width: root_width,
+          height: root_height,
+          level: root.level,
+          shape: root.shape,
+          icon: root.icon,
+          classes: root.classes,
+          original: root
+        }
+
+        # Position children recursively
+        if root.children.any?
+          position_children(
+            root,
+            root_x,
+            ROOT_PADDING + root_height + LEVEL_VERTICAL_SPACING,
+            nodes
+          )
+        end
+
+        nodes
+      end
+
+      # Positions children of a node
+      #
+      # @param parent [Diagram::Mindmap::MindmapNode] parent node
+      # @param parent_x [Numeric] parent X position
+      # @param y [Numeric] Y position for this level
+      # @param nodes [Array<Hash>] accumulator for positioned nodes
+      def position_children(parent, parent_x, y, nodes)
+        children = parent.children
+        return if children.empty?
+
+        # Calculate total width needed for all children
+        total_width = children.sum { |c| estimate_subtree_width(c) }
+        total_width += (children.size - 1) * NODE_HORIZONTAL_SPACING
+
+        # Start x position (centered under parent)
+        start_x = parent_x - (total_width / 2)
+        current_x = start_x
+
+        children.each do |child|
+          child_width = estimate_node_width(child)
+          child_height = estimate_node_height(child)
+          subtree_width = estimate_subtree_width(child)
+
+          # Center the node within its subtree space
+          node_x = current_x + (subtree_width / 2)
+
+          nodes << {
+            id: child.id,
+            content: child.content,
+            x: node_x,
+            y: y,
+            width: child_width,
+            height: child_height,
+            level: child.level,
+            shape: child.shape,
+            icon: child.icon,
+            classes: child.classes,
+            parent_id: parent.id,
+            original: child
+          }
+
+          # Recursively position grandchildren
+          if child.children.any?
+            position_children(
+              child,
+              node_x,
+              y + child_height + LEVEL_VERTICAL_SPACING,
+              nodes
+            )
+          end
+
+          current_x += subtree_width + NODE_HORIZONTAL_SPACING
+        end
+      end
+
+      # Estimates the width of a single node based on content and shape
+      #
+      # @param node [Diagram::Mindmap::MindmapNode] node
+      # @return [Numeric] estimated width
+      def estimate_node_width(node)
+        # Base width on content length
+        content_length = node.content.to_s.length
+        base_width = [content_length * 8 + 20, DEFAULT_NODE_WIDTH].max
+
+        # Adjust for shape
+        case node.shape
+        when "circle", "hexagon"
+          base_width * 1.2
+        else
+          base_width
+        end
+      end
+
+      # Estimates the height of a node
+      #
+      # @param node [Diagram::Mindmap::MindmapNode] node
+      # @return [Numeric] estimated height
+      def estimate_node_height(node)
+        DEFAULT_NODE_HEIGHT
+      end
+
+      # Calculates the total width needed for a subtree
+      #
+      # @param node [Diagram::Mindmap::MindmapNode] root of subtree
+      # @return [Numeric] total width
+      def estimate_subtree_width(node)
+        node_width = estimate_node_width(node)
+        return node_width if node.children.empty?
+
+        # Width is max of node width or sum of children widths
+        children_width = node.children.sum { |c| estimate_subtree_width(c) }
+        children_width += (node.children.size - 1) * NODE_HORIZONTAL_SPACING
+
+        [node_width, children_width].max
+      end
+
+      # Calculates the total width of the entire tree
+      #
+      # @param root [Diagram::Mindmap::MindmapNode] root node
+      # @return [Numeric] tree width
+      def calculate_tree_width(root)
+        estimate_subtree_width(root) + ROOT_PADDING * 2
+      end
+
+      # Builds connections between parent and child nodes
+      #
+      # @param node [Diagram::Mindmap::MindmapNode] current node
+      # @param connections [Array<Hash>] accumulator
+      # @return [Array<Hash>] all connections
+      def build_connections(node, connections = [])
+        node.children.each do |child|
+          connections << {
+            from: node.id,
+            to: child.id,
+            type: :parent_child
+          }
+
+          # Recursively build connections for children
+          build_connections(child, connections)
+        end
+
+        connections
+      end
+
+      # Calculates the bounding box for all positioned nodes
+      #
+      # @param nodes [Array<Hash>] positioned nodes
+      # @return [Hash] width and height
+      def calculate_bounds(nodes)
+        return { width: 0, height: 0 } if nodes.empty?
+
+        max_x = nodes.map { |n| n[:x] + n[:width] / 2 }.max
+        max_y = nodes.map { |n| n[:y] + n[:height] }.max
+
+        {
+          width: max_x + ROOT_PADDING,
+          height: max_y + ROOT_PADDING
+        }
+      end
+    end
+  end
+end

data/lib/sirena/transform/packet.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Sirena
+  module Transform
+    # Transforms a PacketDiagram into a positioned layout structure.
+    #
+    # The layout algorithm handles:
+    # - Organizing fields into rows based on bit positions
+    # - Calculating cell positions in the packet grid
+    # - Handling fields that span multiple bits
+    # - Typical packet width is 32 bits per row
+    #
+    # @example Transform a packet diagram
+    #   transform = Transform::Packet.new
+    #   layout = transform.to_graph(diagram)
+    class Packet
+      # Default number of bits per row (standard packet width)
+      BITS_PER_ROW = 32
+
+      # Cell dimensions
+      CELL_WIDTH = 30
+      CELL_HEIGHT = 40
+
+      # Padding around the diagram
+      PADDING = 40
+
+      # Header height for bit position markers
+      HEADER_HEIGHT = 30
+
+      # Title spacing
+      TITLE_HEIGHT = 40
+      TITLE_MARGIN = 20
+
+      # Transforms the diagram into a layout structure.
+      #
+      # @param diagram [Diagram::PacketDiagram] the packet diagram
+      # @return [Hash] layout data with positioned fields and dimensions
+      def to_graph(diagram)
+        return empty_layout if diagram.fields.empty?
+
+        # Calculate the number of rows needed
+        row_count = diagram.row_count(BITS_PER_ROW)
+
+        # Position each field
+        positioned_fields = position_fields(diagram.fields, row_count)
+
+        # Calculate dimensions
+        width = BITS_PER_ROW * CELL_WIDTH + (PADDING * 2)
+        content_height = row_count * CELL_HEIGHT + HEADER_HEIGHT
+        title_offset = diagram.title ? TITLE_HEIGHT + TITLE_MARGIN : 0
+        height = content_height + (PADDING * 2) + title_offset
+
+        {
+          fields: positioned_fields,
+          row_count: row_count,
+          bits_per_row: BITS_PER_ROW,
+          cell_width: CELL_WIDTH,
+          cell_height: CELL_HEIGHT,
+          padding: PADDING,
+          header_height: HEADER_HEIGHT,
+          title_height: diagram.title ? TITLE_HEIGHT : 0,
+          title_margin: diagram.title ? TITLE_MARGIN : 0,
+          width: width,
+          height: height,
+          title: diagram.title
+        }
+      end
+
+      private
+
+      # Returns an empty layout structure.
+      #
+      # @return [Hash] empty layout
+      def empty_layout
+        {
+          fields: [],
+          row_count: 0,
+          bits_per_row: BITS_PER_ROW,
+          cell_width: CELL_WIDTH,
+          cell_height: CELL_HEIGHT,
+          padding: PADDING,
+          header_height: HEADER_HEIGHT,
+          title_height: 0,
+          title_margin: 0,
+          width: PADDING * 2,
+          height: PADDING * 2,
+          title: nil
+        }
+      end
+
+      # Positions all fields in the grid.
+      #
+      # @param fields [Array<Diagram::PacketField>] fields to position
+      # @param row_count [Integer] total number of rows
+      # @return [Array<Hash>] positioned fields with coordinates
+      def position_fields(fields, row_count)
+        positioned = []
+
+        fields.each do |field|
+          # Handle fields that may span multiple rows
+          if field.spans_rows?(BITS_PER_ROW)
+            # Split into multiple visual segments
+            positioned.concat(split_field_across_rows(field))
+          else
+            # Single row field
+            positioned << position_single_field(field)
+          end
+        end
+
+        positioned
+      end
+
+      # Positions a field that fits in a single row.
+      #
+      # @param field [Diagram::PacketField] field to position
+      # @return [Hash] positioned field data
+      def position_single_field(field)
+        row = field.start_row(BITS_PER_ROW)
+        start_col = field.start_bit_in_row(BITS_PER_ROW)
+        end_col = field.end_bit_in_row(BITS_PER_ROW)
+
+        x = PADDING + (start_col * CELL_WIDTH)
+        y = PADDING + HEADER_HEIGHT + (row * CELL_HEIGHT)
+        width = (end_col - start_col + 1) * CELL_WIDTH
+        height = CELL_HEIGHT
+
+        {
+          label: field.label,
+          bit_start: field.bit_start,
+          bit_end: field.bit_end,
+          x: x,
+          y: y,
+          width: width,
+          height: height,
+          row: row,
+          start_col: start_col,
+          end_col: end_col
+        }
+      end
+
+      # Splits a field that spans multiple rows into visual segments.
+      #
+      # @param field [Diagram::PacketField] field to split
+      # @return [Array<Hash>] array of positioned segments
+      def split_field_across_rows(field)
+        segments = []
+        current_bit = field.bit_start
+
+        while current_bit <= field.bit_end
+          row = current_bit / BITS_PER_ROW
+          start_col = current_bit % BITS_PER_ROW
+
+          # Determine end column for this row
+          row_end_bit = ((row + 1) * BITS_PER_ROW) - 1
+          segment_end_bit = [field.bit_end, row_end_bit].min
+          end_col = segment_end_bit % BITS_PER_ROW
+
+          x = PADDING + (start_col * CELL_WIDTH)
+          y = PADDING + HEADER_HEIGHT + (row * CELL_HEIGHT)
+          width = (end_col - start_col + 1) * CELL_WIDTH
+          height = CELL_HEIGHT
+
+          segments << {
+            label: field.label,
+            bit_start: current_bit,
+            bit_end: segment_end_bit,
+            x: x,
+            y: y,
+            width: width,
+            height: height,
+            row: row,
+            start_col: start_col,
+            end_col: end_col,
+            is_continuation: current_bit > field.bit_start,
+            is_final: segment_end_bit == field.bit_end
+          }
+
+          current_bit = segment_end_bit + 1
+        end
+
+        segments
+      end
+    end
+  end
+end

data/lib/sirena/transform/pie.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../diagram/pie'
+
+module Sirena
+  module Transform
+    # Pie chart transformer for converting pie models to renderable structure.
+    #
+    # Unlike flowcharts and sequence diagrams which require complex layout
+    # computation, pie charts have a fixed circular layout. This transformer
+    # simply validates and prepares the diagram data for direct rendering.
+    #
+    # @example Transform a pie chart
+    #   transform = PieTransform.new
+    #   data = transform.to_graph(pie_diagram)
+    class PieTransform < Base
+      # Converts a pie diagram to a simple data structure.
+      #
+      # Pie charts don't need graph layout computation since they have
+      # a fixed circular layout. This method validates the diagram and
+      # returns a simple structure for the renderer.
+      #
+      # @param diagram [Diagram::Pie] the pie diagram to transform
+      # @return [Hash] data structure for rendering
+      # @raise [TransformError] if diagram is invalid
+      def to_graph(diagram)
+        raise TransformError, 'Invalid diagram' unless diagram.valid?
+
+        {
+          id: diagram.id || 'pie',
+          title: diagram.title,
+          show_data: diagram.show_data || false,
+          acc_title: diagram.acc_title,
+          acc_description: diagram.acc_description,
+          slices: transform_slices(diagram),
+          metadata: {
+            total_value: diagram.total_value,
+            slice_count: (diagram.slices || []).length
+          }
+        }
+      end
+
+      private
+
+      def transform_slices(diagram)
+        return [] if diagram.slices.nil? || diagram.slices.empty?
+
+        diagram.slices.map.with_index do |slice, index|
+          {
+            id: "slice_#{index}",
+            label: slice.label,
+            value: slice.value,
+            percentage: slice.percentage(diagram.total_value),
+            angle: diagram.slice_angle(slice),
+            index: index
+          }
+        end
+      end
+    end
+  end
+end