elkrb 1.0.0 → 2.0.0

data/lib/elkrb/layout/constraints/relative_position_constraint.rb

@@ -21,25 +21,18 @@ module Elkrb
       class RelativePositionConstraint < BaseConstraint
         # Apply relative position constraint
         #
-        # Positions nodes relative to their reference nodes.
-        # Processes in order of position_priority to handle chains.
+        # Positions nodes relative to their reference nodes, a node only
+        # after the node it is relative to. Among nodes whose references are
+        # settled, higher position_priority goes first, then input order.
+        # Nodes on a relative_to cycle, and nodes whose reference is missing
+        # or has no coordinates, are left where they are; #validate reports
+        # them.
         #
         # @param graph [Graph::Graph] The graph
         # @return [Graph::Graph] The modified graph
         def apply(graph)
-          nodes_with_relative = all_nodes(graph).select do |node|
-            node.constraints&.relative_to &&
-              node.constraints.relative_offset
-          end
-
-          # Sort by priority (higher priority processed first)
-          nodes_with_relative.sort_by! do |node|
-            -(node.constraints.position_priority || 0)
-          end
-
-          # Apply relative positioning
-          nodes_with_relative.each do |node|
-            apply_relative_position(node, graph)
+          resolution_order(graph).each do |node|
+            position_relative(node, graph)
           end
 
           graph
@@ -47,63 +40,114 @@ module Elkrb
 
         # Validate relative position constraints
         #
-        # Checks that reference nodes exist and positions are correct.
+        # Checks that reference nodes exist, that relative_to does not form a
+        # cycle, and that positions are correct.
         #
         # @param graph [Graph::Graph] The graph to validate
         # @return [Array<String>] List of validation errors
         def validate(graph)
-          errors = []
-
-          all_nodes(graph).each do |node|
-            next unless node.constraints&.relative_to
+          cyclic = cyclic_nodes(graph)
 
-            ref_id = node.constraints.relative_to
-            ref_node = find_node(graph, ref_id)
+          all_nodes(graph).flat_map do |node|
+            next [] unless node.constraints&.relative_to
 
-            if ref_node.nil?
-              errors << "Node '#{node.id}' has relative_to constraint " \
-                        "referencing '#{ref_id}' which doesn't exist"
-              next
-            end
-
-            # Validate position if offset is specified
-            if node.constraints.relative_offset
-              expected_x = ref_node.x + node.constraints.relative_offset.x
-              expected_y = ref_node.y + node.constraints.relative_offset.y
-
-              tolerance = 0.01
-              if (node.x - expected_x).abs > tolerance ||
-                  (node.y - expected_y).abs > tolerance
-                errors << "Node '#{node.id}' relative position incorrect. " \
-                          "Expected (#{expected_x}, #{expected_y}), " \
-                          "got (#{node.x}, #{node.y})"
-              end
+            if cyclic.any? { |member| member.equal?(node) }
+              ["Node '#{node.id}' is on, or depends on, a relative_to cycle"]
+            else
+              check_relative_node(node, graph)
             end
           end
-
-          errors
         end
 
         private
 
-        # Apply relative position to a single node
-        def apply_relative_position(node, graph)
+        def check_relative_node(node, graph)
           ref_id = node.constraints.relative_to
           ref_node = find_node(graph, ref_id)
 
-          unless ref_node
-            warn "Warning: Node '#{node.id}' references non-existent " \
-                 "node '#{ref_id}' for relative positioning"
-            return
+          if ref_node.nil?
+            return ["Node '#{node.id}' has relative_to constraint " \
+                    "referencing '#{ref_id}' which doesn't exist"]
           end
 
           offset = node.constraints.relative_offset
-          return unless offset
+          return [] unless offset
+
+          unless coordinates?(node) && coordinates?(ref_node)
+            return ["Node '#{node.id}' relative position cannot be checked: " \
+                    "'#{node.id}' or '#{ref_id}' has no coordinates"]
+          end
+
+          expected_x = ref_node.x + offset.x
+          expected_y = ref_node.y + offset.y
+          return [] if within_tolerance?(node, expected_x, expected_y)
+
+          ["Node '#{node.id}' relative position incorrect. " \
+           "Expected (#{expected_x}, #{expected_y}), " \
+           "got (#{node.x}, #{node.y})"]
+        end
+
+        def within_tolerance?(node, expected_x, expected_y)
+          tolerance = 0.01
+          (node.x - expected_x).abs <= tolerance &&
+            (node.y - expected_y).abs <= tolerance
+        end
+
+        def coordinates?(node)
+          !node.x.nil? && !node.y.nil?
+        end
+
+        # Apply relative position to a single node
+        def position_relative(node, graph)
+          ref_node = find_node(graph, node.constraints.relative_to)
+          offset = node.constraints.relative_offset
+          return unless ref_node && offset && coordinates?(ref_node)
 
-          # Calculate and set new position
           node.x = ref_node.x + offset.x
           node.y = ref_node.y + offset.y
         end
+
+        # Nodes to position, each after the node it is relative to.
+        def resolution_order(graph)
+          pending = positioned_nodes(graph)
+          order = []
+
+          until pending.empty?
+            ready = pending.select { |node| ready?(node, graph, pending) }
+            break if ready.empty?
+
+            node = ready.min_by do |candidate|
+              [-(candidate.constraints.position_priority || 0),
+               pending.index { |p| p.equal?(candidate) }]
+            end
+            pending.delete_if { |p| p.equal?(node) }
+            order << node
+          end
+
+          order
+        end
+
+        # A node is ready when the node it is relative to is not itself
+        # still waiting to be positioned.
+        def ready?(node, graph, pending)
+          ref_node = find_node(graph, node.constraints.relative_to)
+          ref_node.nil? || pending.none? { |p| p.equal?(ref_node) }
+        end
+
+        def positioned_nodes(graph)
+          all_nodes(graph).select do |node|
+            node.constraints&.relative_to && node.constraints.relative_offset
+          end
+        end
+
+        # Nodes that can never be ready because relative_to leads back to
+        # them.
+        def cyclic_nodes(graph)
+          ordered = resolution_order(graph)
+          positioned_nodes(graph).reject do |node|
+            ordered.any? { |placed| placed.equal?(node) }
+          end
+        end
       end
     end
   end