elkrb 1.0.0 → 2.0.0

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../node_index"
+require_relative "../polyomino/component_compactor"
+
 module Elkrb
   module Layout
     module Algorithms
@@ -10,6 +13,13 @@ module Elkrb
       # 2. Laying out each component independently
       # 3. Arranging components in a grid or row
       class Disco < BaseAlgorithm
+        # ELK's default edge thickness, which widens an edge's footprint.
+        EDGE_THICKNESS = 1.0
+        # DisCo packs for a square unless the graph names an aspect ratio;
+        # the registry default of elk.aspectRatio belongs to other algorithms.
+        DEFAULT_ASPECT_RATIO = 1.0
+        private_constant :EDGE_THICKNESS, :DEFAULT_ASPECT_RATIO
+
         def layout_flat(graph, _options = {})
           return graph if graph.children.empty?
 
@@ -17,13 +27,13 @@ module Elkrb
           components = find_connected_components(graph)
 
           # Layout each component independently
-          component_algo = graph.layout_options&.[]("disco.componentAlgorithm") || "layered"
+          component_algo = resolver.get("disco.componentAlgorithm", graph)
           components.each do |component|
             layout_component(component, component_algo)
           end
 
           # Arrange components
-          spacing = graph.layout_options&.[]("disco.componentSpacing") || 20.0
+          spacing = resolver.get("disco.componentSpacing", graph)
           arrange_components(components, graph, spacing)
 
           # Apply padding
@@ -35,53 +45,45 @@ module Elkrb
         private
 
         def find_connected_components(graph)
+          index = NodeIndex.build(graph)
           visited = Set.new
           components = []
 
           graph.children.each do |node|
-            next if visited.include?(node)
+            next if visited.include?(node.id)
 
-            component = {
-              nodes: [],
-              edges: [],
-            }
+            nodes = []
 
             # 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
+              next if visited.include?(current.id)
+
+              visited.add(current.id)
+              nodes << current
 
-              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) }
+              (graph.edges || []).each do |edge|
+                endpoints = index.endpoint_nodes(edge.sources) +
+                  index.endpoint_nodes(edge.targets)
+                next unless endpoints.include?(current)
+
+                endpoints.each { |n| queue << n unless visited.include?(n.id) }
               end
             end
 
-            components << component
+            # Compute this component's edges once the whole node set is
+            # known, rather than per visited node — accumulating them
+            # incrementally during the walk records each edge twice
+            # (once from its source side, once from its target side).
+            node_ids = Set.new(nodes.map(&:id))
+            edges = (graph.edges || []).select do |edge|
+              endpoints = index.endpoint_nodes(edge.sources) +
+                index.endpoint_nodes(edge.targets)
+              endpoints.any? { |n| node_ids.include?(n.id) }
+            end
+
+            components << { nodes: nodes, edges: edges }
           end
 
           components
@@ -97,19 +99,42 @@ module Elkrb
 
           # Get algorithm from registry
           algorithm_class = Layout::AlgorithmRegistry.get(algorithm_name)
-          return unless algorithm_class
+          raise Elkrb::AlgorithmNotFoundError, algorithm_name unless algorithm_class
 
           # Apply layout algorithm to component
           algorithm = algorithm_class.new
           algorithm.layout(temp_graph)
+
+          # The component was routed in its own coordinate space and is about
+          # to be shifted into place, so those sections are stale the moment
+          # it moves. The outer routing pass is the authoritative one — hand
+          # it a clean slate instead of letting it append to pre-offset bends.
+          component[:edges].each { |edge| edge.sections = nil }
+        end
+
+        # disco.componentCompaction.strategy is ELK's key; its one value,
+        # POLYOMINO, is also the default. disco.componentArrangement is the
+        # older elkrb key and takes ROW, COLUMN or GRID, and so does the
+        # strategy key. The graph names either key before the call does: the
+        # first reader sees the graph alone. A graph that names
+        # disco.componentArrangement and not the strategy gets that
+        # arrangement.
+        def component_arrangement(graph)
+          keys = %w[disco.componentCompaction.strategy disco.componentArrangement]
+          raw = [Options::Resolver.new, resolver].product(keys)
+            .filter_map { |reader, key| reader.get(key, graph, default: nil) }
+            .first || resolver.get(keys.first, graph)
+          raw.to_s.downcase
         end
 
         def arrange_components(components, graph, spacing)
           return if components.empty?
 
-          arrangement = graph.layout_options&.[]("disco.componentArrangement") || "row"
+          arrangement = component_arrangement(graph)
 
           case arrangement
+          when "polyomino"
+            arrange_by_polyomino(components, graph, spacing)
           when "grid"
             arrange_in_grid(components, spacing)
           when "column"
@@ -119,22 +144,96 @@ module Elkrb
           end
         end
 
+        # Packs the components the way ELK's DisCo does. A component's edges
+        # have no route yet (the outer pass routes them), so each counts as the
+        # straight line between its end nodes, as wide as the spacing.
+        def arrange_by_polyomino(components, graph, spacing)
+          aspect_ratio = resolver.get("elk.aspectRatio", graph, default: DEFAULT_ASPECT_RATIO)
+          unless aspect_ratio.positive?
+            raise ValidationError, "elk.aspectRatio must be above zero, got #{aspect_ratio}"
+          end
+
+          index = NodeIndex.build(graph)
+          shapes = components.map { |component| component_shapes(component, index, spacing) }
+          offsets = Polyomino::ComponentCompactor.new(shapes, aspect_ratio: aspect_ratio).offsets
+
+          components.zip(offsets).each do |component, (dx, dy)|
+            component[:nodes].each do |node|
+              node.x = (node.x || 0.0) + dx
+              node.y = (node.y || 0.0) + dy
+            end
+          end
+        end
+
+        def component_shapes(component, index, spacing)
+          nodes = component[:nodes]
+          shapes = nodes.flat_map { |node| node_shapes(node, spacing) }
+          component[:edges].each do |edge|
+            ends = (index.endpoint_nodes(edge.sources) + index.endpoint_nodes(edge.targets)).uniq
+            next unless ends.size == 2 && ends.all? { |n| nodes.include?(n) }
+
+            shapes << edge_shape(ends[0], ends[1], EDGE_THICKNESS + spacing)
+          end
+          shapes
+        end
+
+        # The node, and each label and port that has a position, grown by half
+        # the spacing on every side.
+        def node_shapes(node, spacing)
+          x = node.x || 0.0
+          y = node.y || 0.0
+          boxes = [[x, y, node.width, node.height]]
+          boxes += positioned(node.labels, x, y)
+          (node.ports || []).each do |port|
+            next unless port.x && port.y
+
+            px = x + port.x
+            py = y + port.y
+            boxes << [px, py, port.width, port.height]
+            boxes += positioned(port.labels, px, py)
+          end
+          boxes.map { |bx, by, w, h| grown_rectangle(bx, by, w || 0.0, h || 0.0, spacing / 2.0) }
+        end
+
+        def positioned(labels, left, top)
+          (labels || []).select { |label| label.x && label.y }
+            .map { |label| [left + label.x, top + label.y, label.width, label.height] }
+        end
+
+        def grown_rectangle(left_edge, top_edge, width, height, margin)
+          left = left_edge - margin
+          top = top_edge - margin
+          right = left_edge + width + margin
+          bottom = top_edge + height + margin
+          [[left, top], [left, bottom], [right, bottom], [right, top]]
+        end
+
+        def edge_shape(from, to, thickness)
+          ax = (from.x || 0.0) + ((from.width || 0.0) / 2.0)
+          ay = (from.y || 0.0) + ((from.height || 0.0) / 2.0)
+          bx = (to.x || 0.0) + ((to.width || 0.0) / 2.0)
+          by = (to.y || 0.0) + ((to.height || 0.0) / 2.0)
+          length = Math.hypot(bx - ax, by - ay)
+          return grown_rectangle(ax, ay, 0.0, 0.0, thickness / 2.0) if length.zero?
+
+          nx = (by - ay) / length * (thickness / 2.0)
+          ny = (ax - bx) / length * (thickness / 2.0)
+          [[ax + nx, ay + ny], [bx + nx, by + ny], [bx - nx, by - ny], [ax - nx, ay - ny]]
+        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
+            box = calculate_bounding_box(component[:nodes])
 
             # Offset all nodes in component
-            offset_x = x_offset - min_x
+            offset_x = x_offset - box.x
             component[:nodes].each do |node|
               node.x += offset_x
             end
 
-            x_offset += component_width + spacing
+            x_offset += box.width + spacing
           end
         end
 
@@ -142,18 +241,15 @@ module Elkrb
           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
+            box = calculate_bounding_box(component[:nodes])
 
             # Offset all nodes in component
-            offset_y = y_offset - min_y
+            offset_y = y_offset - box.y
             component[:nodes].each do |node|
               node.y += offset_y
             end
 
-            y_offset += component_height + spacing
+            y_offset += box.height + spacing
           end
         end
 
@@ -177,23 +273,16 @@ module Elkrb
 
               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
+              box = calculate_bounding_box(component[:nodes])
 
               # Offset nodes
               component[:nodes].each do |node|
-                node.x += x_offset - min_x
-                node.y += y_offset - min_y
+                node.x += x_offset - box.x
+                node.y += y_offset - box.y
               end
 
-              x_offset += component_width + spacing
-              max_row_height = [max_row_height, component_height].max
+              x_offset += box.width + spacing
+              max_row_height = [max_row_height, box.height].max
             end
 
             row_heights << max_row_height

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

@@ -7,25 +7,85 @@ module Elkrb
     module Algorithms
       # Fixed layout algorithm
       #
-      # Keeps nodes at their current positions. Only applies padding
-      # and calculates graph dimensions based on existing node positions.
+      # Keeps nodes at their current positions and calculates graph dimensions
+      # without translating them.
       # 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
+          graph.children.each { |node| apply_position(node) }
 
-          # Simply apply padding and calculate dimensions
-          # Nodes keep their existing x, y positions
-          apply_padding(graph)
+          size_graph(graph)
 
           graph
         end
+
+        private
+
+        def apply_position(node)
+          position = resolver.get("elk.position", node, default: nil)
+          node.x = position ? position.x : (node.x || 0.0)
+          node.y = position ? position.y : (node.y || 0.0)
+        end
+
+        def size_graph(graph)
+          pad = padding
+          graph.width = max_right(graph) + horizontal_padding(pad)
+          graph.height = max_bottom(graph) + vertical_padding(pad)
+        end
+
+        def max_right(graph)
+          graph.children.map { |node| right_edge(node) }.max
+        end
+
+        def max_bottom(graph)
+          graph.children.map { |node| bottom_edge(node) }.max
+        end
+
+        def right_edge(node)
+          node.x + (node.width || 0.0)
+        end
+
+        def bottom_edge(node)
+          node.y + (node.height || 0.0)
+        end
+
+        def horizontal_padding(pad)
+          pad[:left] + pad[:right]
+        end
+
+        def vertical_padding(pad)
+          pad[:top] + pad[:bottom]
+        end
+
+        def padding
+          option(
+            "elk.padding",
+            default: { left: 15.0, top: 15.0, right: 15.0, bottom: 15.0 },
+          ).to_h
+        end
+
+        # Fixed layout preserves routes. It only applies explicitly declared
+        # bend points and records the containing graph.
+        def apply_edge_routing(graph)
+          (graph.edges || []).each do |edge|
+            bends = resolver.get("elk.bendPoints", edge, default: nil)
+            apply_bends(edge, bends) if bends
+            edge.container = graph.id
+          end
+        end
+
+        def apply_bends(edge, bends)
+          edge.sections ||= []
+          section = edge.sections.first || Graph::EdgeSection.new(
+            id: "#{edge.id}_s0",
+          )
+          section.bend_points = bends.vectors.map do |point|
+            Geometry::Point.new(x: point.x, y: point.y)
+          end
+          edge.sections = [section]
+        end
       end
     end
   end