elkrb 1.0.0

data/lib/elkrb/layout/algorithms/disco.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # DISCO (Disconnected Graph Layout) algorithm
+      #
+      # Handles graphs with disconnected components by:
+      # 1. Identifying connected components
+      # 2. Laying out each component independently
+      # 3. Arranging components in a grid or row
+      class Disco < BaseAlgorithm
+        def layout_flat(graph, _options = {})
+          return graph if graph.children.empty?
+
+          # Find connected components
+          components = find_connected_components(graph)
+
+          # Layout each component independently
+          component_algo = graph.layout_options&.[]("disco.componentAlgorithm") || "layered"
+          components.each do |component|
+            layout_component(component, component_algo)
+          end
+
+          # Arrange components
+          spacing = graph.layout_options&.[]("disco.componentSpacing") || 20.0
+          arrange_components(components, graph, spacing)
+
+          # Apply padding
+          apply_padding(graph)
+
+          graph
+        end
+
+        private
+
+        def find_connected_components(graph)
+          visited = Set.new
+          components = []
+
+          graph.children.each do |node|
+            next if visited.include?(node)
+
+            component = {
+              nodes: [],
+              edges: [],
+            }
+
+            # BFS to find all connected nodes
+            queue = [node]
+            while queue.any?
+              current = queue.shift
+              next if visited.include?(current)
+
+              visited.add(current)
+              component[:nodes] << current
+
+              # Find connected nodes through edges
+              connected_edges = graph.edges.select do |edge|
+                edge_nodes = []
+                edge.sources&.each do |port|
+                  edge_nodes << (port.respond_to?(:node) ? port.node : port)
+                end
+                edge.targets&.each do |port|
+                  edge_nodes << (port.respond_to?(:node) ? port.node : port)
+                end
+                edge_nodes.include?(current)
+              end
+
+              component[:edges].concat(connected_edges)
+
+              connected_edges.each do |edge|
+                nodes = []
+                edge.sources&.each do |port|
+                  nodes << (port.respond_to?(:node) ? port.node : port)
+                end
+                edge.targets&.each do |port|
+                  nodes << (port.respond_to?(:node) ? port.node : port)
+                end
+                nodes.each { |n| queue << n unless visited.include?(n) }
+              end
+            end
+
+            components << component
+          end
+
+          components
+        end
+
+        def layout_component(component, algorithm_name)
+          return if component[:nodes].empty?
+
+          # Create a temporary graph for this component
+          temp_graph = Graph::Graph.new
+          temp_graph.children = component[:nodes]
+          temp_graph.edges = component[:edges]
+
+          # Get algorithm from registry
+          algorithm_class = Layout::AlgorithmRegistry.get(algorithm_name)
+          return unless algorithm_class
+
+          # Apply layout algorithm to component
+          algorithm = algorithm_class.new
+          algorithm.layout(temp_graph)
+        end
+
+        def arrange_components(components, graph, spacing)
+          return if components.empty?
+
+          arrangement = graph.layout_options&.[]("disco.componentArrangement") || "row"
+
+          case arrangement
+          when "grid"
+            arrange_in_grid(components, spacing)
+          when "column"
+            arrange_in_column(components, spacing)
+          else
+            arrange_in_row(components, spacing)
+          end
+        end
+
+        def arrange_in_row(components, spacing)
+          x_offset = 0.0
+
+          components.each do |component|
+            # Calculate component bounds
+            min_x = component[:nodes].map(&:x).min || 0.0
+            max_x = component[:nodes].map { |n| n.x + n.width }.max || 0.0
+            component_width = max_x - min_x
+
+            # Offset all nodes in component
+            offset_x = x_offset - min_x
+            component[:nodes].each do |node|
+              node.x += offset_x
+            end
+
+            x_offset += component_width + spacing
+          end
+        end
+
+        def arrange_in_column(components, spacing)
+          y_offset = 0.0
+
+          components.each do |component|
+            # Calculate component bounds
+            min_y = component[:nodes].map(&:y).min || 0.0
+            max_y = component[:nodes].map { |n| n.y + n.height }.max || 0.0
+            component_height = max_y - min_y
+
+            # Offset all nodes in component
+            offset_y = y_offset - min_y
+            component[:nodes].each do |node|
+              node.y += offset_y
+            end
+
+            y_offset += component_height + spacing
+          end
+        end
+
+        def arrange_in_grid(components, spacing)
+          return if components.empty?
+
+          # Calculate grid dimensions
+          cols = Math.sqrt(components.size).ceil
+          rows = (components.size.to_f / cols).ceil
+
+          y_offset = 0.0
+          row_heights = []
+
+          rows.times do |row|
+            x_offset = 0.0
+            max_row_height = 0.0
+
+            cols.times do |col|
+              index = (row * cols) + col
+              break if index >= components.size
+
+              component = components[index]
+
+              # Calculate component bounds
+              min_x = component[:nodes].map(&:x).min || 0.0
+              min_y = component[:nodes].map(&:y).min || 0.0
+              max_x = component[:nodes].map { |n| n.x + n.width }.max || 0.0
+              max_y = component[:nodes].map { |n| n.y + n.height }.max || 0.0
+
+              component_width = max_x - min_x
+              component_height = max_y - min_y
+
+              # Offset nodes
+              component[:nodes].each do |node|
+                node.x += x_offset - min_x
+                node.y += y_offset - min_y
+              end
+
+              x_offset += component_width + spacing
+              max_row_height = [max_row_height, component_height].max
+            end
+
+            row_heights << max_row_height
+            y_offset += max_row_height + spacing
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/fixed.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base_algorithm"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # Fixed layout algorithm
+      #
+      # Keeps nodes at their current positions. Only applies padding
+      # and calculates graph dimensions based on existing node positions.
+      # Useful when node positions are pre-determined or manually set.
+      class Fixed < BaseAlgorithm
+        def layout_flat(graph, _options = {})
+          return graph if graph.children.nil? || graph.children.empty?
+
+          # Ensure all nodes have positions
+          graph.children.each do |node|
+            node.x ||= 0.0
+            node.y ||= 0.0
+          end
+
+          # Simply apply padding and calculate dimensions
+          # Nodes keep their existing x, y positions
+          apply_padding(graph)
+
+          graph
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/force.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "base_algorithm"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # Force-directed layout algorithm
+      #
+      # Creates organic, symmetric layouts using force simulation.
+      # Nodes repel each other while edges act as springs pulling
+      # connected nodes together.
+      #
+      # Ideal for:
+      # - Network diagrams
+      # - Social graphs
+      # - Mind maps
+      # - General undirected graphs
+      class Force < BaseAlgorithm
+        DEFAULT_ITERATIONS = 300
+        DEFAULT_REPULSION = 5.0
+        DEFAULT_TEMPERATURE = 0.001
+
+        def layout_flat(graph, _options = {})
+          return graph if graph.children.nil? || graph.children.empty?
+
+          # Get configuration
+          iterations = option("iterations", DEFAULT_ITERATIONS).to_i
+          repulsion = option("repulsion", DEFAULT_REPULSION).to_f
+          temperature = option("temperature", DEFAULT_TEMPERATURE).to_f
+
+          # Initialize positions randomly if not set
+          initialize_positions(graph)
+
+          # Run force simulation
+          iterations.times do |i|
+            apply_forces(graph, repulsion, temperature, i, iterations)
+          end
+
+          # Apply padding and set graph dimensions
+          apply_padding(graph)
+
+          graph
+        end
+
+        private
+
+        def initialize_positions(graph)
+          # Calculate approximate area needed
+          total_area = graph.children.sum do |n|
+            (n.width + 20) * (n.height + 20)
+          end
+          side = Math.sqrt(total_area)
+
+          graph.children.each do |node|
+            # Set random position if not already set
+            unless node.x && node.y
+              node.x = rand * side
+              node.y = rand * side
+            end
+          end
+        end
+
+        def apply_forces(graph, repulsion, temperature, iteration,
+                         max_iterations)
+          # Calculate temperature decay
+          temp = temperature * (1.0 - (iteration.to_f / max_iterations))
+
+          # Calculate forces for each node
+          forces = calculate_forces(graph, repulsion)
+
+          # Apply forces with temperature
+          graph.children.each_with_index do |node, i|
+            force = forces[i]
+            magnitude = Math.sqrt((force[:x]**2) + (force[:y]**2))
+
+            next if magnitude.zero?
+
+            # Apply displacement with temperature
+            displacement = [magnitude, temp].min
+            node.x += (force[:x] / magnitude) * displacement
+            node.y += (force[:y] / magnitude) * displacement
+          end
+        end
+
+        def calculate_forces(graph, repulsion)
+          forces = graph.children.map { { x: 0.0, y: 0.0 } }
+
+          # Repulsive forces between all pairs
+          graph.children.each_with_index do |node1, i|
+            graph.children.each_with_index do |node2, j|
+              next if i >= j
+
+              apply_repulsive_force(node1, node2, forces[i], forces[j],
+                                    repulsion)
+            end
+          end
+
+          # Attractive forces for edges
+          all_edges = collect_all_edges(graph)
+          all_edges.each do |edge|
+            source_id = edge.sources&.first
+            target_id = edge.targets&.first
+
+            next unless source_id && target_id
+
+            source_idx = graph.children.index { |n| n.id == source_id }
+            target_idx = graph.children.index { |n| n.id == target_id }
+
+            next unless source_idx && target_idx
+
+            apply_attractive_force(
+              graph.children[source_idx],
+              graph.children[target_idx],
+              forces[source_idx],
+              forces[target_idx],
+            )
+          end
+
+          forces
+        end
+
+        def apply_repulsive_force(node1, node2, force1, force2, repulsion)
+          dx = node2.x - node1.x
+          dy = node2.y - node1.y
+          distance_sq = (dx**2) + (dy**2)
+
+          # Avoid division by zero
+          return if distance_sq < 0.01
+
+          # Repulsive force inversely proportional to distance
+          force = repulsion / distance_sq
+          force1[:x] -= (dx / Math.sqrt(distance_sq)) * force
+          force1[:y] -= (dy / Math.sqrt(distance_sq)) * force
+          force2[:x] += (dx / Math.sqrt(distance_sq)) * force
+          force2[:y] += (dy / Math.sqrt(distance_sq)) * force
+        end
+
+        def apply_attractive_force(node1, node2, force1, force2)
+          dx = node2.x - node1.x
+          dy = node2.y - node1.y
+          distance = Math.sqrt((dx**2) + (dy**2))
+
+          return if distance.zero?
+
+          # Spring force proportional to distance
+          force = distance / 10.0
+          force1[:x] += (dx / distance) * force
+          force1[:y] += (dy / distance) * force
+          force2[:x] -= (dx / distance) * force
+          force2[:y] -= (dy / distance) * force
+        end
+
+        def collect_all_edges(graph)
+          edges = []
+          edges.concat(graph.edges) if graph.edges
+          graph.children&.each do |node|
+            edges.concat(node.edges) if node.edges
+          end
+          edges
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/cycle_breaker.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        # Breaks cycles in the graph to make it acyclic
+        #
+        # This is the first phase of the Sugiyama framework.
+        # Uses a greedy approach to reverse edges that create cycles.
+        class CycleBreaker
+          def initialize(graph)
+            @graph = graph
+            @visited = {}
+            @in_stack = {}
+            @edges_to_reverse = []
+          end
+
+          def break_cycles
+            return unless @graph.children
+
+            # Find all edges that create cycles using DFS
+            @graph.children.each do |node|
+              dfs(node) unless @visited[node.id]
+            end
+
+            # Reverse the problematic edges
+            reverse_edges
+
+            @edges_to_reverse
+          end
+
+          private
+
+          def dfs(node)
+            @visited[node.id] = true
+            @in_stack[node.id] = true
+
+            # Process outgoing edges
+            get_outgoing_edges(node).each do |edge|
+              target_id = edge.targets.first
+              next unless target_id
+
+              target = @graph.find_node(target_id)
+              next unless target
+
+              if @in_stack[target.id]
+                # Found a cycle - mark this edge for reversal
+                @edges_to_reverse << edge
+              elsif !@visited[target.id]
+                dfs(target)
+              end
+            end
+
+            @in_stack[node.id] = false
+          end
+
+          def get_outgoing_edges(node)
+            edges = []
+
+            # Get edges from the node itself
+            edges.concat(node.edges) if node.edges
+
+            # Get edges from the graph that have this node as source
+            @graph.edges&.each do |edge|
+              edges << edge if edge.sources&.include?(node.id)
+            end
+
+            edges
+          end
+
+          def reverse_edges
+            @edges_to_reverse.each do |edge|
+              # Swap sources and targets
+              edge.sources, edge.targets = edge.targets, edge.sources
+
+              # Mark as reversed for later processing
+              edge.properties ||= {}
+              edge.properties["reversed"] = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/layer_assigner.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        # Assigns nodes to layers in the graph
+        #
+        # This is the second phase of the Sugiyama framework.
+        # Uses longest path layering to create a balanced layout.
+        class LayerAssigner
+          attr_reader :layers
+
+          def initialize(graph)
+            @graph = graph
+            @layers = []
+            @node_layers = {}
+          end
+
+          def assign_layers
+            return [] unless @graph.children
+
+            # Calculate layer for each node
+            @graph.children.each do |node|
+              calculate_layer(node)
+            end
+
+            # Group nodes by layer
+            max_layer = @node_layers.values.max || 0
+            @layers = Array.new(max_layer + 1) { [] }
+
+            @node_layers.each do |node_id, layer|
+              node = @graph.find_node(node_id)
+              @layers[layer] << node if node
+            end
+
+            @layers
+          end
+
+          def get_layer(node_id)
+            @node_layers[node_id]
+          end
+
+          private
+
+          def calculate_layer(node)
+            return @node_layers[node.id] if @node_layers.key?(node.id)
+
+            # Find incoming edges
+            incoming = get_incoming_edges(node)
+
+            if incoming.empty?
+              # Root node - assign to layer 0
+              @node_layers[node.id] = 0
+            else
+              # Assign to one layer below the maximum of predecessors
+              max_pred_layer = incoming.filter_map do |edge|
+                source_id = edge.sources.first
+                next 0 unless source_id
+
+                source = @graph.find_node(source_id)
+                next 0 unless source
+
+                calculate_layer(source)
+              end.max || 0
+
+              @node_layers[node.id] = max_pred_layer + 1
+            end
+
+            @node_layers[node.id]
+          end
+
+          def get_incoming_edges(node)
+            edges = []
+
+            # Get all edges that target this node
+            @graph.edges&.each do |edge|
+              edges << edge if edge.targets&.include?(node.id)
+            end
+
+            # Also check edges from other nodes
+            @graph.children&.each do |other_node|
+              next unless other_node.edges
+
+              other_node.edges.each do |edge|
+                edges << edge if edge.targets&.include?(node.id)
+              end
+            end
+
+            edges
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered/node_placer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Layout
+    module Algorithms
+      module Layered
+        # Places nodes within their assigned layers
+        #
+        # This phase calculates the x and y coordinates for each node
+        # based on their layer assignment and spacing requirements.
+        class NodePlacer
+          def initialize(graph, layers, options = {})
+            @graph = graph
+            @layers = layers
+            @options = options
+            @layer_spacing = options[:layer_spacing] || 60.0
+            @node_spacing = options[:spacing_node_node] || 20.0
+          end
+
+          def place_nodes
+            return unless @layers && !@layers.empty?
+
+            # Calculate layer widths
+            layer_widths = calculate_layer_widths
+
+            # Calculate y positions for each layer
+            y_positions = calculate_layer_y_positions
+
+            # Place nodes in each layer
+            @layers.each_with_index do |layer_nodes, layer_index|
+              place_layer(layer_nodes, layer_index, layer_widths[layer_index],
+                          y_positions[layer_index])
+            end
+          end
+
+          private
+
+          def calculate_layer_widths
+            @layers.map do |layer_nodes|
+              return 0 if layer_nodes.empty?
+
+              total_width = layer_nodes.sum { |n| n.width || 0 }
+              total_spacing = (layer_nodes.length - 1) * @node_spacing
+              total_width + total_spacing
+            end
+          end
+
+          def calculate_layer_y_positions
+            y = 0
+            positions = []
+
+            @layers.each do |layer_nodes|
+              positions << y
+              max_height = layer_nodes.map { |n| n.height || 0 }.max || 0
+              y += max_height + @layer_spacing
+            end
+
+            positions
+          end
+
+          def place_layer(nodes, _layer_index, _layer_width, y_pos)
+            return if nodes.empty?
+
+            # Center the layer horizontally
+            x = 0
+
+            nodes.each do |node|
+              node.x = x
+              node.y = y_pos
+              x += (node.width || 0) + @node_spacing
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/layout/algorithms/layered.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "base_algorithm"
+require_relative "layered/cycle_breaker"
+require_relative "layered/layer_assigner"
+require_relative "layered/node_placer"
+
+module Elkrb
+  module Layout
+    module Algorithms
+      # Layered (Sugiyama) layout algorithm
+      #
+      # The flagship algorithm for hierarchical graph layout.
+      # Implements the Sugiyama framework in phases:
+      # 1. Cycle breaking - make the graph acyclic
+      # 2. Layer assignment - assign nodes to horizontal layers
+      # 3. Node placement - position nodes within layers
+      #
+      # Ideal for:
+      # - UML class diagrams
+      # - Call graphs
+      # - Data flow diagrams
+      # - Organization charts
+      # - Any directed acyclic graph
+      class LayeredAlgorithm < BaseAlgorithm
+        def layout_flat(graph, _options = {})
+          return graph if graph.children.nil? || graph.children.empty?
+
+          # Phase 1: Break cycles
+          cycle_breaker = Layered::CycleBreaker.new(graph)
+          cycle_breaker.break_cycles
+
+          # Phase 2: Assign layers
+          layer_assigner = Layered::LayerAssigner.new(graph)
+          layers = layer_assigner.assign_layers
+
+          # Phase 3: Place nodes
+          node_placer = Layered::NodePlacer.new(graph, layers, @options)
+          node_placer.place_nodes
+
+          # Apply padding and set graph dimensions
+          apply_padding(graph)
+
+          graph
+        end
+      end
+    end
+  end
+end