kumiki 0.1.1

data/lib/kumiki/markdown/mermaid/layout.rb

@@ -0,0 +1,389 @@
+module Kumiki
+  # Mermaid flowchart layout - BFS layered graph layout
+  # Assigns x, y, width, height to all nodes and subgraphs
+
+  class MermaidLayout
+    def layout(diagram, max_width, padding)
+      if diagram.nodes.length == 0
+        return
+      end
+
+      assign_layers(diagram)
+      calculate_node_sizes(diagram)
+
+      horizontal = diagram.direction == MERMAID_DIR_LR || diagram.direction == MERMAID_DIR_RL
+      if horizontal
+        position_horizontal(diagram, padding)
+      else
+        position_vertical(diagram, padding, max_width)
+      end
+
+      position_subgraphs(diagram)
+    end
+
+    def assign_layers(diagram)
+      # Simple BFS layering using node.layer field
+      # First, set all layers to -1 (unvisited)
+      i = 0
+      while i < diagram.nodes.length
+        diagram.nodes[i].layer = -1
+        i = i + 1
+      end
+
+      # Find root nodes (not a target of any edge)
+      i = 0
+      while i < diagram.nodes.length
+        n = diagram.nodes[i]
+        is_root = true
+        ei = 0
+        while ei < diagram.edges.length
+          if diagram.edges[ei].target == n.id
+            is_root = false
+            break
+          end
+          ei = ei + 1
+        end
+        if is_root
+          n.layer = 0
+        end
+        i = i + 1
+      end
+
+      # If no roots, set first node as root
+      has_root = false
+      i = 0
+      while i < diagram.nodes.length
+        if diagram.nodes[i].layer == 0
+          has_root = true
+          break
+        end
+        i = i + 1
+      end
+      if !has_root && diagram.nodes.length > 0
+        diagram.nodes[0].layer = 0
+      end
+
+      # BFS: propagate layers from roots to children
+      # Only assign to unvisited nodes (layer < 0) to handle cycles gracefully
+      changed = true
+      max_iters = diagram.nodes.length
+      iter = 0
+      while changed && iter < max_iters
+        changed = false
+        ei = 0
+        while ei < diagram.edges.length
+          edge = diagram.edges[ei]
+          src = diagram.get_node(edge.source)
+          tgt = diagram.get_node(edge.target)
+          if src && tgt && src.layer >= 0 && tgt.layer < 0
+            tgt.layer = src.layer + 1
+            changed = true
+          end
+          ei = ei + 1
+        end
+        iter = iter + 1
+      end
+
+      # Set any remaining unvisited nodes to layer 0
+      i = 0
+      while i < diagram.nodes.length
+        if diagram.nodes[i].layer < 0
+          diagram.nodes[i].layer = 0
+        end
+        i = i + 1
+      end
+    end
+
+    def calculate_node_sizes(diagram)
+      char_width = 8.0
+      min_width = 100.0
+      node_height = 40.0
+
+      i = 0
+      while i < diagram.nodes.length
+        n = diagram.nodes[i]
+        label_w = n.label.length * char_width + 24.0
+        if label_w < min_width
+          label_w = min_width
+        end
+        n.width = label_w
+        n.height = node_height
+
+        if n.shape == MERMAID_SHAPE_CIRCLE
+          max_dim = n.width
+          if n.height > max_dim
+            max_dim = n.height
+          end
+          n.width = max_dim
+          n.height = max_dim
+        elsif n.shape == MERMAID_SHAPE_DIAMOND
+          n.width = n.width + 20.0
+          n.height = n.width * 0.6
+        end
+        i = i + 1
+      end
+    end
+
+    def max_layer(diagram)
+      mx = 0
+      i = 0
+      while i < diagram.nodes.length
+        if diagram.nodes[i].layer > mx
+          mx = diagram.nodes[i].layer
+        end
+        i = i + 1
+      end
+      mx
+    end
+
+    def position_vertical(diagram, padding, max_width)
+      h_spacing = 40.0
+      v_spacing = 60.0
+      ml = max_layer(diagram)
+      reverse = diagram.direction == MERMAID_DIR_BT
+
+      # First pass: find max total width across all layers
+      max_w = find_max_layer_width(diagram, ml, h_spacing)
+      if max_w < 1.0
+        max_w = max_width
+      end
+
+      # Second pass: position nodes
+      y_offset = padding
+      layer = 0
+      while layer <= ml
+        actual = layer
+        if reverse
+          actual = ml - layer
+        end
+        position_layer_vertical(diagram, actual, y_offset, padding, max_w, h_spacing)
+        tallest = layer_max_height(diagram, actual)
+        y_offset = y_offset + tallest + v_spacing
+        layer = layer + 1
+      end
+    end
+
+    def find_max_layer_width(diagram, ml, spacing)
+      max_w = 0.0
+      layer = 0
+      while layer <= ml
+        w = compute_layer_width(diagram, layer, spacing)
+        if w > max_w
+          max_w = w
+        end
+        layer = layer + 1
+      end
+      max_w
+    end
+
+    def compute_layer_width(diagram, layer, spacing)
+      total = 0.0
+      count = 0
+      i = 0
+      while i < diagram.nodes.length
+        if diagram.nodes[i].layer == layer
+          total = total + diagram.nodes[i].width
+          count = count + 1
+        end
+        i = i + 1
+      end
+      if count > 1
+        total = total + (count - 1) * spacing
+      end
+      total
+    end
+
+    def position_layer_vertical(diagram, layer, y, padding, max_w, spacing)
+      lw = compute_layer_width(diagram, layer, spacing)
+      start_x = padding + (max_w - lw) / 2.0
+      x = start_x
+      i = 0
+      while i < diagram.nodes.length
+        n = diagram.nodes[i]
+        if n.layer == layer
+          n.x = x
+          n.y = y
+          x = x + n.width + spacing
+        end
+        i = i + 1
+      end
+    end
+
+    def layer_max_height(diagram, layer)
+      mx = 0.0
+      i = 0
+      while i < diagram.nodes.length
+        if diagram.nodes[i].layer == layer && diagram.nodes[i].height > mx
+          mx = diagram.nodes[i].height
+        end
+        i = i + 1
+      end
+      mx
+    end
+
+    def position_horizontal(diagram, padding)
+      h_spacing = 40.0
+      v_spacing = 60.0
+      ml = max_layer(diagram)
+      reverse = diagram.direction == MERMAID_DIR_RL
+
+      # Find max total height across all layers
+      max_h = find_max_layer_height(diagram, ml, h_spacing)
+
+      # Position nodes
+      x_offset = padding
+      layer = 0
+      while layer <= ml
+        actual = layer
+        if reverse
+          actual = ml - layer
+        end
+        position_layer_horizontal(diagram, actual, x_offset, padding, max_h, h_spacing)
+        widest = layer_max_width(diagram, actual)
+        x_offset = x_offset + widest + v_spacing
+        layer = layer + 1
+      end
+    end
+
+    def find_max_layer_height(diagram, ml, spacing)
+      max_h = 0.0
+      layer = 0
+      while layer <= ml
+        h = compute_layer_height(diagram, layer, spacing)
+        if h > max_h
+          max_h = h
+        end
+        layer = layer + 1
+      end
+      max_h
+    end
+
+    def compute_layer_height(diagram, layer, spacing)
+      total = 0.0
+      count = 0
+      i = 0
+      while i < diagram.nodes.length
+        if diagram.nodes[i].layer == layer
+          total = total + diagram.nodes[i].height
+          count = count + 1
+        end
+        i = i + 1
+      end
+      if count > 1
+        total = total + (count - 1) * spacing
+      end
+      total
+    end
+
+    def position_layer_horizontal(diagram, layer, x, padding, max_h, spacing)
+      lh = compute_layer_height(diagram, layer, spacing)
+      start_y = padding + (max_h - lh) / 2.0
+      y = start_y
+      i = 0
+      while i < diagram.nodes.length
+        n = diagram.nodes[i]
+        if n.layer == layer
+          n.x = x
+          n.y = y
+          y = y + n.height + spacing
+        end
+        i = i + 1
+      end
+    end
+
+    def layer_max_width(diagram, layer)
+      mx = 0.0
+      i = 0
+      while i < diagram.nodes.length
+        if diagram.nodes[i].layer == layer && diagram.nodes[i].width > mx
+          mx = diagram.nodes[i].width
+        end
+        i = i + 1
+      end
+      mx
+    end
+
+    def position_subgraphs(diagram)
+      sg_padding = 15.0
+      title_height = 20.0
+
+      si = 0
+      while si < diagram.subgraphs.length
+        sg = diagram.subgraphs[si]
+        if sg.node_ids.length > 0
+          compute_subgraph_bounds(diagram, sg, sg_padding, title_height)
+        end
+        si = si + 1
+      end
+    end
+
+    def compute_subgraph_bounds(diagram, sg, sg_padding, title_height)
+      min_x = 99999.0
+      min_y = 99999.0
+      max_x = 0.0
+      max_y = 0.0
+
+      ni = 0
+      while ni < sg.node_ids.length
+        node = diagram.get_node(sg.node_ids[ni])
+        if node
+          if node.x < min_x
+            min_x = node.x
+          end
+          if node.y < min_y
+            min_y = node.y
+          end
+          right = node.x + node.width
+          if right > max_x
+            max_x = right
+          end
+          bottom = node.y + node.height
+          if bottom > max_y
+            max_y = bottom
+          end
+        end
+        ni = ni + 1
+      end
+
+      sg.x = min_x - sg_padding
+      sg.y = min_y - sg_padding - title_height
+      sg.width = (max_x - min_x) + sg_padding * 2.0
+      sg.height = (max_y - min_y) + sg_padding * 2.0 + title_height
+    end
+
+    def calculate_height(diagram)
+      max_y = 0.0
+      i = 0
+      while i < diagram.nodes.length
+        bottom = diagram.nodes[i].y + diagram.nodes[i].height
+        if bottom > max_y
+          max_y = bottom
+        end
+        i = i + 1
+      end
+      i = 0
+      while i < diagram.subgraphs.length
+        bottom = diagram.subgraphs[i].y + diagram.subgraphs[i].height
+        if bottom > max_y
+          max_y = bottom
+        end
+        i = i + 1
+      end
+      max_y + 20.0
+    end
+
+    def calculate_width(diagram)
+      max_x = 0.0
+      i = 0
+      while i < diagram.nodes.length
+        right = diagram.nodes[i].x + diagram.nodes[i].width
+        if right > max_x
+          max_x = right
+        end
+        i = i + 1
+      end
+      max_x + 20.0
+    end
+  end
+
+end

data/lib/kumiki/markdown/mermaid/models.rb

@@ -0,0 +1,235 @@
+module Kumiki
+  # Mermaid diagram data models
+  # Direction, shape, line type, arrow type constants and node/edge/subgraph classes
+
+  # Direction constants
+  MERMAID_DIR_TB = 0
+  MERMAID_DIR_BT = 1
+  MERMAID_DIR_LR = 2
+  MERMAID_DIR_RL = 3
+
+  # Node shape constants
+  MERMAID_SHAPE_RECT = 0
+  MERMAID_SHAPE_ROUNDED = 1
+  MERMAID_SHAPE_STADIUM = 2
+  MERMAID_SHAPE_CIRCLE = 3
+  MERMAID_SHAPE_DIAMOND = 4
+  MERMAID_SHAPE_HEXAGON = 5
+  MERMAID_SHAPE_SUBROUTINE = 6
+
+  # Line type constants
+  MERMAID_LINE_SOLID = 0
+  MERMAID_LINE_DASHED = 1
+  MERMAID_LINE_THICK = 2
+
+  # Arrow type constants
+  MERMAID_ARROW_ARROW = 0
+  MERMAID_ARROW_OPEN = 1
+  MERMAID_ARROW_CIRCLE = 2
+  MERMAID_ARROW_CROSS = 3
+
+  class MermaidNode
+    def initialize(id, label, shape)
+      @id = id
+      @label = label
+      @shape = shape
+      @x = 0.0
+      @y = 0.0
+      @width = 0.0
+      @height = 0.0
+      @layer = 0
+    end
+
+    def id
+      @id
+    end
+
+    def label
+      @label
+    end
+
+    def label=(v)
+      @label = v
+    end
+
+    def shape
+      @shape
+    end
+
+    def shape=(v)
+      @shape = v
+    end
+
+    def x
+      @x
+    end
+
+    def x=(v)
+      @x = v
+    end
+
+    def y
+      @y
+    end
+
+    def y=(v)
+      @y = v
+    end
+
+    def width
+      @width
+    end
+
+    def width=(v)
+      @width = v
+    end
+
+    def height
+      @height
+    end
+
+    def height=(v)
+      @height = v
+    end
+
+    def layer
+      @layer
+    end
+
+    def layer=(v)
+      @layer = v
+    end
+  end
+
+  class MermaidEdge
+    def initialize(source, target, label, line_type, arrow_type)
+      @source = source
+      @target = target
+      @label = label
+      @line_type = line_type
+      @arrow_type = arrow_type
+    end
+
+    def source
+      @source
+    end
+
+    def target
+      @target
+    end
+
+    def label
+      @label
+    end
+
+    def line_type
+      @line_type
+    end
+
+    def arrow_type
+      @arrow_type
+    end
+  end
+
+  class MermaidSubgraph
+    def initialize(id, title)
+      @id = id
+      @title = title
+      @node_ids = []
+      @x = 0.0
+      @y = 0.0
+      @width = 0.0
+      @height = 0.0
+    end
+
+    def id
+      @id
+    end
+
+    def title
+      @title
+    end
+
+    def node_ids
+      @node_ids
+    end
+
+    def x
+      @x
+    end
+
+    def x=(v)
+      @x = v
+    end
+
+    def y
+      @y
+    end
+
+    def y=(v)
+      @y = v
+    end
+
+    def width
+      @width
+    end
+
+    def width=(v)
+      @width = v
+    end
+
+    def height
+      @height
+    end
+
+    def height=(v)
+      @height = v
+    end
+  end
+
+  class MermaidDiagram
+    def initialize(direction)
+      @direction = direction
+      @nodes = []
+      @edges = []
+      @subgraphs = []
+      @node_map = {}
+    end
+
+    def direction
+      @direction
+    end
+
+    def nodes
+      @nodes
+    end
+
+    def edges
+      @edges
+    end
+
+    def subgraphs
+      @subgraphs
+    end
+
+    def add_node(node)
+      if !@node_map[node.id]
+        @nodes.push(node)
+        @node_map[node.id] = node
+      end
+    end
+
+    def get_node(id)
+      @node_map[id]
+    end
+
+    def add_edge(edge)
+      @edges.push(edge)
+    end
+
+    def add_subgraph(sg)
+      @subgraphs.push(sg)
+    end
+  end
+
+end