elkrb 1.0.0 → 2.0.0

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

@@ -17,10 +17,46 @@ module Elkrb
       # The algorithm calculates grid dimensions to approximate a square
       # aspect ratio, then places nodes from left to right, top to bottom.
       class TopdownPacking < BaseAlgorithm
+        # Fallback cell size when no node anywhere declares a usable width
+        # or height. Mirrors node_spacing's own 20.0 default rather than
+        # inventing a new constant.
+        DEFAULT_CELL_SIZE = 20.0
+
         def initialize(options = {})
           super
         end
 
+        # A declared width or height is only usable when it is finite and
+        # positive. NaN and Infinity are valid YAML float literals (`.nan`,
+        # `.inf`; JSON's parser rejects the bare form) that would otherwise
+        # propagate into every downstream position and crash
+        # calculate_bounding_box's Array#max, whose NaN-vs-NaN comparison
+        # raises ArgumentError. A non-positive value is rejected too --
+        # port_constraint_processor.rb already treats a node as size-less
+        # unless both dimensions are `positive?`, and letting a negative
+        # declared value reach this node's own box (rather than every
+        # node's shared, uniformly-averaged cell size, as before this
+        # file's declared-size-preserving change) inverts its box and
+        # produces a false-negative overlap check against its neighbours.
+        # No type check beyond nil-safety: Node's width/height are declared
+        # `attribute :width, :float` (node.rb), so lutaml casts every
+        # assignment to a Float or nil before it can ever reach here -- a
+        # value that responds to #finite? and is neither nil nor a Numeric
+        # is not a reachable input. A public class method -- it depends on
+        # nothing but its argument, matching the pure-helper convention
+        # already used elsewhere for options parsing (e.g. KVector.parse).
+        # Keep this as a class method with the instance delegate below --
+        # a plain private instance method here trips reek's UtilityFunction
+        # check.
+        #
+        # @param value [Float, nil] The node's declared width or height
+        # @return [Float, nil] The value if usable, nil otherwise
+        def self.finite_dimension(value)
+          return nil unless value&.finite? && value.positive?
+
+          value
+        end
+
         # Layout nodes in a grid using top-down packing
         #
         # @param graph [Elkrb::Graph::Graph] The graph to layout
@@ -96,24 +132,34 @@ module Elkrb
                      height: 0.0 }
           end
 
-          # Get options from graph layout options
-          layout_opts = graph.layout_options || {}
-
-          # Get target aspect ratio (default: 1.0 for square cells)
-          target_aspect_ratio = get_option(layout_opts,
-                                           "topdownpacking.aspectRatio", 1.0).to_f
+          # Get target aspect ratio (default: 1.0 for square cells). A
+          # non-positive ratio falls back to square rather than reaching the
+          # division below; the resolver already rejects NaN and Infinity.
+          target_aspect_ratio = resolver.get("topdownpacking.aspectRatio", graph)
           target_aspect_ratio = 1.0 if target_aspect_ratio <= 0.0
 
           # Calculate node dimensions based on aspect ratio
           # We can either use specified dimensions or calculate from available space
-          node_width_opt = get_option(layout_opts, "topdownpacking.nodeWidth")
+          node_width_opt = finite_dimension(resolver.get("topdownpacking.nodeWidth", graph))
           if node_width_opt
-            node_width = node_width_opt.to_f
+            node_width = node_width_opt
             node_height = node_width / target_aspect_ratio
           else
-            # Calculate from node sizes to maintain proportions
-            avg_width = nodes.sum(&:width) / nodes.size.to_f
-            avg_height = nodes.sum(&:height) / nodes.size.to_f
+            # Calculate from node sizes to maintain proportions. A size-less,
+            # non-finite (NaN/Infinity, both valid YAML float literals) or
+            # non-positive node contributes 0.0 rather than crashing the
+            # average, matching the nil-handling convention in box.rb.
+            avg_width = nodes.sum { |node| finite_dimension(node.width) || 0.0 } / nodes.size.to_f
+            avg_height = nodes.sum { |node| finite_dimension(node.height) || 0.0 } / nodes.size.to_f
+
+            # When no node anywhere declares a usable size, both averages
+            # are zero and every node would silently collapse to a 0x0
+            # footprint. Fall back to a default cell size instead of
+            # discarding every node.
+            if avg_width.zero? && avg_height.zero?
+              avg_width = DEFAULT_CELL_SIZE
+              avg_height = DEFAULT_CELL_SIZE
+            end
 
             # Use the larger dimension as base
             if avg_width >= avg_height
@@ -128,20 +174,24 @@ module Elkrb
           { width: node_width, height: node_height }
         end
 
-        # Get option value from layout options or default
+        # Instance-side delegate to the class method above, so callers in
+        # this file read as one private helper rather than repeating
+        # `self.class` at every call site.
         #
-        # @param layout_opts [Hash, LayoutOptions] The layout options
-        # @param key [String] The option key
-        # @param default [Object] The default value
-        # @return [Object] The option value or default
-        def get_option(layout_opts, key, default = nil)
-          return default unless layout_opts
-
-          value = if layout_opts.respond_to?(:[])
-                    layout_opts[key]
-                  end
-
-          value.nil? ? default : value
+        # @param value [Object] The node's declared width or height
+        # @return [Numeric, nil] The value if usable, nil otherwise
+        def finite_dimension(value)
+          self.class.finite_dimension(value)
+        end
+
+        # Ports were placed on the declared size before layout. A declared
+        # size that is replaced here (size-less, non-positive or non-finite)
+        # leaves them on edges the node no longer has, or never placed.
+        #
+        # @param node [Elkrb::Graph::Node] The node, already resized
+        # @param declared [Array<Numeric, nil>] Its declared width and height
+        def replace_ports_for_resized_node(node, declared)
+          replace_node_ports(node) unless declared.all? { |dim| finite_dimension(dim) }
         end
 
         # Place nodes in grid positions
@@ -155,25 +205,39 @@ module Elkrb
           current_x = 0.0
           current_y = 0.0
           current_col = 0
+          row_height = 0.0
 
           nodes.each do |node|
-            # Set node dimensions
-            node.width = node_width
-            node.height = node_height
+            # Only a node with a usable (finite, positive, non-nil) declared
+            # width/height keeps it -- which means it may be larger than
+            # the cell, so advancing by the fixed cell size (rather than
+            # the node's own size) would let it overlap its neighbours. A
+            # size-less, non-finite (NaN/Infinity) or non-positive declared
+            # value takes the grid cell size instead of reaching position
+            # math as-is.
+            declared_width = node.width
+            declared_height = node.height
+            actual_width = (node.width = finite_dimension(declared_width) || node_width)
+            actual_height = (node.height = finite_dimension(declared_height) || node_height)
+            replace_ports_for_resized_node(node, [declared_width, declared_height])
 
             # Set node position
             node.x = current_x
             node.y = current_y
 
-            # Advance to next position
+            row_height = actual_height if actual_height > row_height
+
+            # Advance to next position, past this node's own footprint
             current_col += 1
-            current_x += node_width + spacing
+            current_x += actual_width + spacing
 
-            # Move to next row if we've filled the current row
+            # Move to next row if we've filled the current row, past the
+            # tallest node actually placed in it
             if current_col >= cols
               current_x = 0.0
-              current_y += node_height + spacing
+              current_y += row_height + spacing
               current_col = 0
+              row_height = 0.0
             end
           end
         end

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

@@ -7,15 +7,12 @@ module Elkrb
     module Algorithms
       # VertiFlex layout algorithm
       #
-      # A vertical flexible layout algorithm that arranges nodes in vertical
-      # columns with optimized spacing. Ideal for timeline-style layouts,
-      # Kanban boards, and vertical flowcharts.
+      # Approximates a column-grid layout: it distributes nodes into a fixed
+      # number of vertical columns (round-robin or sequential) and stacks
+      # each column top to bottom, sizing each column to its widest node.
       #
-      # The algorithm distributes nodes into vertical columns and positions
-      # them with flexible column widths based on the widest node in each
-      # column.
-      #
-      # This is an experimental algorithm matching the Java ELK implementation.
+      # It never reads the graph's edges -- node positions are identical
+      # whether edges are present or not.
       class VertiFlex < BaseAlgorithm
         def initialize(options = {})
           super
@@ -38,34 +35,18 @@ module Elkrb
           end
 
           nodes = graph.children
-          layout_opts = graph.layout_options || {}
 
           # Get layout options
-          column_count = get_option(layout_opts, "vertiflex.columnCount",
-                                    3).to_i
-          column_count = 1 if column_count < 1
-
-          column_spacing = get_option(
-            layout_opts,
-            "vertiflex.columnSpacing",
-            50.0,
-          ).to_f
-
-          vertical_spacing = get_option(
-            layout_opts,
-            "vertiflex.verticalSpacing",
-            30.0,
-          ).to_f
+          column_count = [resolver.get("vertiflex.columnCount", graph), 1].max
+          column_spacing = resolver.get("vertiflex.columnSpacing", graph)
+          vertical_spacing = resolver.get("vertiflex.verticalSpacing", graph)
 
           # Override with elk.spacing.nodeNode if present
-          node_node_spacing = get_option(layout_opts, "elk.spacing.nodeNode")
-          vertical_spacing = node_node_spacing.to_f if node_node_spacing
+          node_node_spacing = resolver.get("elk.spacing.nodeNode", graph,
+                                           default: nil)
+          vertical_spacing = node_node_spacing if node_node_spacing
 
-          balance_columns = get_option(
-            layout_opts,
-            "vertiflex.balanceColumns",
-            true,
-          )
+          balance_columns = resolver.get("vertiflex.balanceColumns", graph)
 
           # Distribute nodes into columns
           columns = distribute_nodes(nodes, column_count, balance_columns)
@@ -80,22 +61,6 @@ module Elkrb
 
         private
 
-        # Get option value from layout options or default
-        #
-        # @param layout_opts [Hash, LayoutOptions] The layout options
-        # @param key [String] The option key
-        # @param default [Object] The default value
-        # @return [Object] The option value or default
-        def get_option(layout_opts, key, default = nil)
-          return default unless layout_opts
-
-          value = if layout_opts.respond_to?(:[])
-                    layout_opts[key]
-                  end
-
-          value.nil? ? default : value
-        end
-
         # Distribute nodes into columns
         #
         # @param nodes [Array<Elkrb::Graph::Node>] Nodes to distribute

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

@@ -31,7 +31,17 @@ module Elkrb
       #     align_direction: "vertical"
       #   )
       #   # Both nodes will have same x coordinate
+      #
+      # Members that the average would stack on top of each other are moved
+      # apart along the other axis, in their current order.
       class AlignmentConstraint < BaseConstraint
+        # @param spacing [Numeric] minimum gap kept between group members
+        #   along the axis that is not aligned
+        def initialize(spacing: 0.0)
+          super()
+          @spacing = spacing
+        end
+
         # Apply alignment constraint
         #
         # Groups nodes by align_group and aligns them according to
@@ -102,26 +112,53 @@ module Elkrb
           end
         end
 
-        # Align nodes horizontally (same y)
+        # Align nodes horizontally (same y), then space them along x
         def align_horizontally(nodes)
-          # Use average y position
-          avg_y = nodes.filter_map(&:y).sum / nodes.length.to_f
-
-          nodes.each do |node|
-            node.y = avg_y
-          end
+          placed = align_to_average(nodes, :y)
+          space_apart(placed, :x, :width)
         end
 
-        # Align nodes vertically (same x)
+        # Align nodes vertically (same x), then space them along y
         def align_vertically(nodes)
-          # Use average x position
-          avg_x = nodes.filter_map(&:x).sum / nodes.length.to_f
+          placed = align_to_average(nodes, :x)
+          space_apart(placed, :y, :height)
+        end
 
-          nodes.each do |node|
-            node.x = avg_x
+        # Moves every node that has a coordinate on +axis+ to the average of
+        # them. A node without one is left alone: it has nothing to align.
+        #
+        # @return [Array<Graph::Node>] the nodes that were aligned
+        def align_to_average(nodes, axis)
+          placed = nodes.reject { |node| node.public_send(axis).nil? }
+          return placed if placed.empty?
+
+          average = placed.sum { |node| node.public_send(axis) } /
+            placed.length.to_f
+          placed.each { |node| node.public_send(:"#{axis}=", average) }
+        end
+
+        # Pushes members apart along +axis+ so none overlaps the one before
+        # it. Order is the nodes' current order along the axis; ties keep
+        # the order they were given in.
+        def space_apart(nodes, axis, size)
+          ordered = nodes.each_with_index.sort_by do |node, index|
+            [coordinate(node, axis), index]
+          end.map(&:first)
+
+          ordered.each_cons(2) do |previous, node|
+            floor = coordinate(previous, axis) +
+              coordinate(previous, size) + @spacing
+            next unless coordinate(node, axis) < floor
+
+            node.public_send(:"#{axis}=", floor)
           end
         end
 
+        # A coordinate or size that has not been set counts as 0.
+        def coordinate(node, attribute)
+          node.public_send(attribute) || 0.0
+        end
+
         # Validate group alignment
         def validate_group_alignment(nodes, group_name, direction)
           errors = []

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

@@ -32,14 +32,6 @@ module Elkrb
           []
         end
 
-        # Check if constraint applies to this node
-        #
-        # @param node [Graph::Node] The node to check
-        # @return [Boolean] True if constraint applies
-        def applies_to?(node)
-          node.constraints.present?
-        end
-
         protected
 
         # Find node by ID in graph
@@ -50,21 +42,17 @@ module Elkrb
         def find_node(graph, node_id)
           return nil unless graph.children
 
-          graph.children.each do |node|
-            found = node.find_node(node_id)
-            return found if found
-          end
-          nil
+          graph.children.find { |node| node.id == node_id }
         end
 
-        # Get all nodes from graph (including nested)
+        # Get all nodes at this hierarchy level.
         #
         # @param graph [Graph::Graph] The graph
         # @return [Array<Graph::Node>] All nodes
         def all_nodes(graph)
           return [] unless graph.children
 
-          graph.children.flat_map(&:all_nodes)
+          graph.children
         end
       end
     end

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

@@ -14,7 +14,7 @@ module Elkrb
       # Orchestrates the application and validation of all layout constraints.
       # Constraints are applied in a specific order to handle dependencies:
       # 1. Fixed position (locks nodes)
-      # 2. Layer constraints (assigns layers)
+      # 2. Layer constraints (checked; the layered algorithm honours them)
       # 3. Relative position (depends on reference nodes)
       # 4. Alignment (adjusts positions)
       #
@@ -30,15 +30,14 @@ module Elkrb
           LayerConstraint,
         ].freeze
 
-        # Post-layout constraints (enforce after algorithm runs)
-        POST_LAYOUT_CONSTRAINTS = [
-          RelativePositionConstraint,
-          AlignmentConstraint,
-        ].freeze
-
-        def initialize
+        # @param spacing [Numeric] minimum gap alignment keeps between the
+        #   members of one group along the axis it does not align
+        def initialize(spacing: 0.0)
           @pre_constraints = PRE_LAYOUT_CONSTRAINTS.map(&:new)
-          @post_constraints = POST_LAYOUT_CONSTRAINTS.map(&:new)
+          @post_constraints = [
+            RelativePositionConstraint.new,
+            AlignmentConstraint.new(spacing: spacing),
+          ]
           @all_constraints = (@pre_constraints + @post_constraints)
         end
 
@@ -113,20 +112,7 @@ module Elkrb
         def has_constraints?(graph)
           return false unless graph.children
 
-          graph.children.any? do |node|
-            has_constraints_recursive?(node)
-          end
-        end
-
-        private
-
-        # Check if node or its children have constraints
-        def has_constraints_recursive?(node)
-          return true if node.constraints
-
-          return false unless node.children
-
-          node.children.any? { |child| has_constraints_recursive?(child) }
+          graph.children.any?(&:constraints)
         end
       end
     end

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

@@ -16,6 +16,11 @@ module Elkrb
       #   node.constraints = NodeConstraints.new(fixed_position: true)
       #   # After layout, node remains at (500, 800)
       class FixedPositionConstraint < BaseConstraint
+        def initialize
+          super
+          @originals = {}
+        end
+
         # Apply fixed position constraint (pre-layout)
         #
         # Stores original positions of fixed nodes so they can be
@@ -28,11 +33,7 @@ module Elkrb
             next unless node.constraints&.fixed_position
             next if node.x.nil? || node.y.nil?
 
-            # Store original position
-            node.properties ||= {}
-            node.properties["_constraint_fixed"] = true
-            node.properties["_constraint_original_x"] = node.x
-            node.properties["_constraint_original_y"] = node.y
+            @originals[node.id] = [node.x, node.y]
           end
 
           graph
@@ -47,11 +48,10 @@ module Elkrb
         # @return [Graph::Graph] The modified graph
         def restore_fixed_positions(graph)
           all_nodes(graph).each do |node|
-            next unless node.properties&.[]("_constraint_fixed")
+            original = fixed_original(node)
+            next unless original
 
-            # Restore original position
-            node.x = node.properties["_constraint_original_x"]
-            node.y = node.properties["_constraint_original_y"]
+            node.x, node.y = original
           end
 
           graph
@@ -67,10 +67,8 @@ module Elkrb
           errors = []
 
           all_nodes(graph).each do |node|
-            next unless node.properties&.[]("_constraint_fixed")
-
-            original_x = node.properties["_constraint_original_x"]
-            original_y = node.properties["_constraint_original_y"]
+            original_x, original_y = fixed_original(node)
+            next unless original_x
 
             if node.x != original_x || node.y != original_y
               errors << "Node '#{node.id}' has fixed_position constraint " \
@@ -81,6 +79,17 @@ module Elkrb
 
           errors
         end
+
+        private
+
+        # The recorded position of a node that is still fixed, or nil. The
+        # constraint is read from the node every time, so clearing
+        # fixed_position releases a node recorded earlier.
+        def fixed_original(node)
+          return unless node.constraints&.fixed_position
+
+          @originals[node.id]
+        end
       end
     end
   end

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

@@ -17,53 +17,30 @@ module Elkrb
       #   database.constraints = NodeConstraints.new(layer: 2)   # Bottom
       #   # Enforces tier structure
       class LayerConstraint < BaseConstraint
-        # Apply layer constraint
-        #
-        # Marks nodes with layer assignment that layered algorithm
-        # must respect.
+        # Nothing to do before layout: the layered algorithm reads
+        # `constraints.layer` itself when it assigns layers.
         #
         # @param graph [Graph::Graph] The graph
-        # @return [Graph::Graph] The modified graph
+        # @return [Graph::Graph] The graph, unchanged
         def apply(graph)
-          all_nodes(graph).each do |node|
-            next unless node.constraints&.layer
-
-            # Mark node with its required layer
-            node.properties ||= {}
-            node.properties["_constraint_layer"] = node.constraints.layer
-          end
-
           graph
         end
 
         # Validate layer constraints
         #
-        # Checks that nodes assigned to layers are in correct layers.
-        # Note: This validation only applies if the layered algorithm
-        # was used and layer information is available.
+        # A layer index below 0 names no layer, so the layered algorithm
+        # places such a node in layer 0.
         #
         # @param graph [Graph::Graph] The graph to validate
         # @return [Array<String>] List of validation errors
         def validate(graph)
-          errors = []
+          all_nodes(graph).filter_map do |node|
+            layer = node.constraints&.layer
+            next unless layer&.negative?
 
-          # Check if layer information is available
-          # (only present if layered algorithm was used)
-          all_nodes(graph).each do |node|
-            next unless node.constraints&.layer
-            next unless node.properties&.[]("_assigned_layer")
-
-            expected_layer = node.constraints.layer
-            actual_layer = node.properties["_assigned_layer"]
-
-            if expected_layer != actual_layer
-              errors << "Node '#{node.id}' constrained to layer " \
-                        "#{expected_layer} but assigned to layer " \
-                        "#{actual_layer}"
-            end
+            "Node '#{node.id}' constrained to layer #{layer}, " \
+              "which does not exist; layers start at 0"
           end
-
-          errors
         end
       end
     end