elkrb 1.0.0 → 2.0.0

data/lib/elkrb/graphviz_wrapper.rb

@@ -1,14 +1,64 @@
 # frozen_string_literal: true
 
+require "open3"
+require_relative "atomic_destination"
+require_relative "command_resolver"
+
 module Elkrb
-  # Wrapper for optional Graphviz integration
-  # Provides graceful degradation when Graphviz is not installed
+  # Wrapper for optional Graphviz integration.
+  #
+  # A missing Graphviz is a hard failure, not a degraded render. #available?
+  # lets a caller ask first; #render raises GraphvizNotFoundError carrying
+  # the install instructions, and the diagram command re-raises it after
+  # deleting the half-written file rather than leaving DOT text sitting
+  # under a .svg name.
+  #
+  # reek 6.5.0's own directive-comment parser (pinned by the Gemfile's
+  # `~> 6.5.0`; re-check this comment on any reek bump) only recognizes a
+  # `{ ... }` config hash when it appears on a SINGLE comment line --
+  # `Reek::CodeComment::CONFIGURATION_REGEX` has no /m flag, so a `{ }` split
+  # across lines silently fails to parse, and reek falls back to disabling
+  # the WHOLE detector for this class, which is
+  # exactly the whole-class over-reach this is meant to avoid. Measured: a
+  # 4th bang method added under the split form was NOT flagged; under this
+  # one-line form it IS. Verify with `context.config_for(MissingSafeMethod)`
+  # if this line is ever touched -- it must read `{"exclude"=>[...]}`, not
+  # `{"enabled"=>false}`.
+  # rubocop:disable Layout/LineLength
+  # :reek:MissingSafeMethod { exclude: [ validate_engine!, validate_file_exists!, validate_format!, validate_output_file! ] }
+  # rubocop:enable Layout/LineLength
+  # These four are argument validators, not the dangerous/safe pair the
+  # smell looks for; a bang-less companion isn't meaningful for any of them.
+  # Scoped to this exact class by reek's inline-comment mechanism, so a new
+  # bang method added directly on GraphvizWrapper later is NOT silently
+  # exempted. A nested class INHERITS this exclude, though --
+  # `CodeContext#config_for` merges the parent's config in -- which is why
+  # GraphvizNotFoundError below resets it explicitly rather than relying on
+  # this comment's scope.
   class GraphvizWrapper
+    # :reek:MissingSafeMethod { exclude: [] } -- resets the exclude this
+    # nested class would otherwise inherit from GraphvizWrapper above, so a
+    # bang method added here later is not silently exempted by a sibling's
+    # unrelated exclusion.
     class GraphvizNotFoundError < StandardError; end
 
     SUPPORTED_FORMATS = %i[png svg pdf ps eps].freeze
     SUPPORTED_ENGINES = %w[dot neato fdp sfdp twopi circo].freeze
 
+    # "dot" first, so a plain PATH lookup (CommandResolver, PATHEXT-aware on
+    # Windows) always gets the first try. The rest are where the package
+    # managers put `dot` when it is not on PATH. macOS cron and launchd hand
+    # a process /usr/bin:/bin, and Homebrew -- the install route
+    # #installation_message recommends -- is on neither.
+    CANDIDATES = [
+      "dot",
+      "/usr/bin/dot",
+      "/usr/local/bin/dot",
+      "/opt/homebrew/bin/dot",
+      "/opt/local/bin/dot",
+    ].freeze
+    private_constant :CANDIDATES
+
     def initialize
       @dot_path = find_graphviz
     end
@@ -22,21 +72,30 @@ module Elkrb
 
       validate_format!(format)
       validate_file_exists!(dot_file)
+      validate_output_file!(output_file)
 
-      engine = options[:engine] || "dot"
-      validate_engine!(engine)
+      engine, dpi = command_options(options)
 
-      dpi = options[:dpi] || 96
-
-      cmd = build_command(engine, format, dot_file, output_file, dpi)
-      execute_command(cmd)
+      AtomicDestination.generate(
+        output_file, require_nonempty: true
+      ) do |scratch|
+        execute_command(build_command(engine, format, dot_file, scratch, dpi))
+      end
     end
 
+    # `available?` only proves @dot_path resolved to a real, executable file
+    # at CONSTRUCTION time. Between then and this call the binary can be
+    # deleted or lose its execute bit -- measured, Open3.capture2e raises
+    # Errno::ENOENT or Errno::EACCES in exactly those cases, which would
+    # otherwise break #version's own documented "nil when not available"
+    # contract instead of honoring it.
     def version
       return nil unless available?
 
-      output = `#{@dot_path} -V 2>&1`
+      output, = Open3.capture2e(@dot_path, "-V")
       output.match(/version\s+([\d.]+)/i)&.captures&.first
+    rescue SystemCallError
+      nil
     end
 
     def supported_formats
@@ -49,49 +108,80 @@ module Elkrb
 
     private
 
+    def command_options(options)
+      engine, dpi = options.values_at(:engine, :dpi)
+      engine ||= "dot"
+      dpi ||= 96
+      validate_engine!(engine)
+      [engine, dpi]
+    end
+
+    # Finds the Graphviz `dot` executable.
+    #
+    # @return [String, nil] the path to `dot`, or nil if not found
+    #
+    # ELKRB_DOT, if set to a non-empty value, is the sole candidate; a bare
+    # override with no directory is anchored to the working directory first
+    # so it resolves the same way CommandResolver.runnable? checks it.
+    # Resolve the chosen candidate with `File.realpath`, not
+    # `File.expand_path` -- expansion is lexical and gets a path crossing a
+    # symlinked directory wrong.
     def find_graphviz
-      # Try common locations
-      candidates = [
-        "dot",
-        "/usr/bin/dot",
-        "/usr/local/bin/dot",
-        "/opt/homebrew/bin/dot",
-        "/opt/local/bin/dot",
-      ]
-
-      candidates.each do |path|
-        if File.executable?(path)
-          return path
-        elsif system("which #{path} > /dev/null 2>&1")
-          return path
-        end
-      end
+      override = ENV.fetch("ELKRB_DOT", nil)
+      candidates = if override.nil? || override.empty?
+                     CANDIDATES
+                   else
+                     [anchor_bare_name(override)]
+                   end
+      resolved = candidates.lazy
+        .filter_map { |each| CommandResolver.resolved_path(each) }
+        .first
+      resolved && resolve_real(resolved)
+    end
 
-      nil
+    def resolve_real(path)
+      File.realpath(path)
+    rescue SystemCallError
+      path
     end
 
-    def build_command(engine, format, input_file, output_file, dpi)
-      cmd_parts = [
-        @dot_path,
-        "-K#{engine}",
-        "-T#{format}",
-        "-Gdpi=#{dpi}",
-      ]
+    # File.basename strips a directory, so a path that already carries one
+    # comes back different from itself. Backslash counts as a separator on
+    # Windows only, where File::ALT_SEPARATOR is set. On POSIX it is nil, so
+    # a backslash is an ordinary character in a name and such a path anchors
+    # -- which is right, because there it really is a bare name.
+    def anchor_bare_name(path)
+      File.basename(path) == path ? File.join(Dir.pwd, path) : path
+    end
 
-      cmd_parts << "-o#{output_file}" if output_file
-      cmd_parts << input_file
+    # option_safe_path guards both the input and output paths: dot reads a
+    # leading-dash path as an option instead of a positional, so a file
+    # named "-V" would make dot print its banner and write nothing while
+    # reporting success. Both paths go through `File.path` first -- a
+    # `#to_path` object interpolated with `#to_s` instead yields
+    # "#<Object:0x...>", which dot then writes by that literal name.
+    def build_command(engine, format, input_file, output_file, dpi)
+      [@dot_path, "-K#{engine}", "-T#{format}", "-Gdpi=#{dpi}",
+       "-o", option_safe_path(File.path(output_file)),
+       option_safe_path(File.path(input_file))]
+    end
 
-      cmd_parts.join(" ")
+    # Anchors ONLY a name dot would read as an option, and with File.join,
+    # which is purely lexical and leaves any ".." in place for the OS to
+    # resolve. File.absolute_path collapses ".." itself, without consulting
+    # the filesystem, so across a symlinked directory it names a different
+    # file than the OS reaches -- and macOS ships /tmp and /var as symlinks,
+    # so that needs no hand-made link to hit. Every other path is passed
+    # through byte-identical.
+    def option_safe_path(path)
+      path.start_with?("-") ? File.join(Dir.pwd, path) : path
     end
 
-    def execute_command(cmd)
-      success = system(cmd)
-      unless success
-        raise GraphvizNotFoundError,
-              "Graphviz command failed: #{cmd}"
-      end
+    def execute_command(argv)
+      success = system(*argv)
+      return success if success
 
-      success
+      raise GraphvizNotFoundError, "Graphviz command failed: #{argv.inspect}"
     end
 
     def validate_format!(format)
@@ -109,12 +199,28 @@ module Elkrb
                            "Supported engines: #{SUPPORTED_ENGINES.join(', ')}"
     end
 
+    # Only a readable regular file will do. File.exist? is also true of a
+    # directory, and dot handed one exits 0 having written nothing, so the
+    # caller printed a render that never happened.
     def validate_file_exists!(file)
-      return if File.exist?(file)
+      return if File.file?(file) && File.readable?(file)
 
       raise ArgumentError, "Input file not found: #{file}"
     end
 
+    # Empty counts as missing; BLANK does not. Measured: `render(input,
+    # "   ", :png)` writes a real file named "   ", because three spaces
+    # is a legal POSIX filename -- so do not reach for `strip` here. An
+    # empty path, by contrast, reaches `dot` as a bare `-o` with nothing
+    # after it, which prints its whole usage banner to stderr and then
+    # fails as GraphvizNotFoundError, blaming a Graphviz that is installed
+    # and working.
+    def validate_output_file!(output_file)
+      return unless output_file.to_s.empty?
+
+      raise ArgumentError, "Output file path is required"
+    end
+
     def installation_message
       <<~MSG
         Graphviz is required but not found.
@@ -127,6 +233,8 @@ module Elkrb
 
         Alternatively, export to DOT format and render manually:
           elkrb diagram input.json -o output.dot
+
+        If Graphviz is installed but not on PATH, set ELKRB_DOT=/path/to/dot
       MSG
     end
   end

data/lib/elkrb/layout/algorithm_registry.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../options/registry"
+
 module Elkrb
   module Layout
     class AlgorithmRegistry
@@ -7,15 +9,28 @@ module Elkrb
       @metadata = {}
 
       class << self
+        # Resolves the same way #get does, so re-registering an algorithm
+        # under another spelling replaces it instead of standing up a second
+        # entry beside it under the folded key.
         def register(name, algorithm_class, metadata = {})
-          name_str = name.to_s
+          name_str = resolve_key(name)
           @algorithms[name_str] = algorithm_class
           @metadata[name_str] = metadata
         end
 
         def get(name)
-          algorithm_name = normalize_name(name)
-          @algorithms[algorithm_name]
+          @algorithms[resolve_key(name)]
+        end
+
+        # @api private
+        # @param name [String] an algorithm name, in any spelling #get takes
+        # @return [String, nil] the key the algorithm is registered under, or
+        #   nil when none is, as for a name with invalid bytes
+        def registered_name(name)
+          return unless name.to_s.valid_encoding?
+
+          key = resolve_key(name)
+          key if @algorithms.key?(key)
         end
 
         def available_algorithms
@@ -23,10 +38,10 @@ module Elkrb
         end
 
         def algorithm_info(name)
-          algorithm_class = get(name)
+          name_str = resolve_key(name)
+          algorithm_class = @algorithms[name_str]
           return nil unless algorithm_class
 
-          name_str = normalize_name(name)
           metadata = @metadata[name_str] || {}
 
           {
@@ -35,6 +50,7 @@ module Elkrb
             description: metadata[:description] || "",
             category: metadata[:category] || "general",
             supports_hierarchy: metadata[:supports_hierarchy] || false,
+            supported_options: supported_options_for(name_str, algorithm_class),
           }
         end
 
@@ -44,11 +60,52 @@ module Elkrb
 
         private
 
+        # Core (algorithms: :all) registry ids apply generically through
+        # BaseAlgorithm's shared mixins (padding, spacing, labels, ports,
+        # self-loops). A custom registration using the "compatible
+        # interface" escape hatch documented on .register_algorithm (not
+        # inheriting BaseAlgorithm) does not get those mixins for free,
+        # so it advertises only its own algorithm-specific ids. Checked
+        # via `defined?` rather than a require: base_algorithm.rb pulls
+        # in the full Graph model chain, which this file must not require
+        # just to be usable on its own (this class works standalone) —
+        # by the time any real caller invokes #algorithm_info, the gem's
+        # normal load order has already defined BaseAlgorithm anyway.
+        def supported_options_for(name_str, algorithm_class)
+          base = ::Elkrb::Layout::Algorithms::BaseAlgorithm if defined?(::Elkrb::Layout::Algorithms::BaseAlgorithm)
+          # #ancestors answers the same question as Class#<= and returns a real
+          # boolean. `<=` answers nil for an unrelated class, which the
+          # escape-hatch path would then hand down as a flag.
+          include_all = !base.nil? && algorithm_class.ancestors.include?(base)
+          Options::Registry.for_algorithm(name_str, include_all: include_all)
+        end
+
+        # Used by #get and #algorithm_info to find the key actually
+        # registered for `name`: try the properly snake_cased form first,
+        # then fall back to the plain downcased form for the handful of
+        # legacy run-together registrations ("mrtree", "libavoid", ...)
+        # that predate word-boundary folding. Falls back to the folded
+        # form even when unregistered, so callers always get a single,
+        # well-defined key back rather than nil.
+        def resolve_key(name)
+          folded = normalize_name(name)
+          return folded if @algorithms.key?(folded)
+
+          legacy = legacy_normalize_name(name)
+          @algorithms.key?(legacy) ? legacy : folded
+        end
+
         def normalize_name(name)
-          # Support both full names and short names
-          # e.g., "org.eclipse.elk.layered" -> "layered"
+          # "org.eclipse.elk.sporeOverlap" / "sporeOverlap" / "spore_overlap"
+          # all fold to the same "spore_overlap" key.
+          name = name.to_s
+          name = name.split(".").last.to_s if name.include?(".")
+          name.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+        end
+
+        def legacy_normalize_name(name)
           name = name.to_s
-          name = name.split(".").last if name.include?(".")
+          name = name.split(".").last.to_s if name.include?(".")
           name.downcase
         end
       end

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

@@ -5,6 +5,7 @@ require_relative "../hierarchical_processor"
 require_relative "../label_placer"
 require_relative "../port_constraint_processor"
 require_relative "../constraints/constraint_processor"
+require_relative "../../options/resolver"
 
 module Elkrb
   module Layout
@@ -20,45 +21,57 @@ module Elkrb
         include LabelPlacer
         include PortConstraintProcessor
 
-        attr_reader :options
+        attr_reader :options, :resolver
 
         def initialize(options = {})
           @options = options
+          @resolver = Options::Resolver.new(options)
         end
 
-        # Main layout method - automatically handles hierarchical graphs and labels
+        # Default a node's unset x/y to 0.0, matching Java ELK's treatment
+        # of an unset position. Shared by algorithms (currently SporeOverlap
+        # and SporeCompaction) that read node.x/node.y arithmetically before
+        # any other pass has had a chance to assign them. A class method
+        # because it depends only on its argument, never on an instance's
+        # state (reek: UtilityFunction fires on the instance-method form).
+        #
+        # @param nodes [Array<Elkrb::Graph::Node>] The nodes to normalize
+        def self.normalize_nil_positions(nodes)
+          nodes.each do |node|
+            node.x ||= 0.0
+            node.y ||= 0.0
+          end
+        end
+
+        # Main layout method - handles hierarchical graphs and labels.
         #
         # Subclasses should implement #layout_flat for their specific
-        # algorithm logic. This method will automatically handle hierarchical
-        # graphs by calling layout_hierarchical when needed, and place labels
-        # after layout is complete.
+        # algorithm logic. This method sizes compound children bottom-up, then
+        # lays out this level and places its labels.
         #
         # @param graph [Elkrb::Graph::Graph] The graph to layout
         # @return [Elkrb::Graph::Graph] The graph with updated positions
         def layout(graph)
-          # Apply port constraints before layout
-          apply_port_constraints(graph)
-
-          # Apply pre-layout constraints (marks nodes)
-          apply_pre_layout_constraints(graph)
+          @graph = graph
 
-          # Perform layout
-          if option("hierarchical", false) || graph.hierarchical?
-            layout_hierarchical(graph, @options)
-          else
-            layout_flat(graph, @options)
-          end
-
-          # Enforce post-layout constraints (adjust positions)
-          enforce_post_layout_constraints(graph)
+          # Compound sizes must be known before their own ports or the parent
+          # level are laid out. Each child algorithm recursively sizes deeper
+          # compounds before returning.
+          size_compound_children(graph) if graph.hierarchical?
 
-          # Apply edge routing
+          apply_port_constraints(graph)
+          processor = apply_pre_layout_constraints(graph)
+
+          # Only nil (children key absent from deserialized
+          # input) skips dispatch — an explicit empty array still reaches
+          # layout_flat, preserving its documented NotImplementedError
+          # contract for subclasses that don't override it.
+          layout_flat(graph, @options) if graph.children
+          enforce_post_layout_constraints(graph, processor)
           apply_edge_routing(graph)
-
-          # Place labels after layout (unless disabled)
-          unless option("label.placement.disabled", false)
-            place_labels(graph)
-          end
+          route_cross_level_edges(graph)
+          place_labels(graph) unless
+            option("label.placement.disabled", default: false)
 
           graph
         end
@@ -78,35 +91,33 @@ module Elkrb
 
         protected
 
-        # Get an option value with a default fallback
+        # Get an option value, resolved against the graph being laid out and
+        # then the call-level options (see Options::Resolver for the rule).
         #
-        # @param key [String, Symbol] The option key
-        # @param default [Object] The default value if option is not set
+        # @param key [String, Symbol] The option id, alias, or custom key
+        # @param default [Object] Returned when nothing names the option;
+        #   :registry means the registry default, nil means nil
         # @return [Object] The option value or default
-        def option(key, default = nil)
-          key_str = key.to_s
-          @options[key_str] || @options[key.to_sym] || default
+        def option(key, default: :registry)
+          @resolver.get(key, @graph, default: default)
+        end
+
+        def rng
+          @rng ||= ::Random.new(option("elk.randomSeed").to_i)
         end
 
         # Get spacing between nodes
         #
         # @return [Float] The node spacing value
         def node_spacing
-          option("spacing_node_node", 20.0).to_f
+          option("elk.spacing.nodeNode").to_f
         end
 
         # Get padding values
         #
         # @return [Hash] Padding values for top, bottom, left, right
         def padding
-          default_padding = { top: 12, bottom: 12, left: 12, right: 12 }
-          padding_opt = option("padding", default_padding)
-
-          if padding_opt.is_a?(Hash)
-            default_padding.merge(padding_opt)
-          else
-            default_padding
-          end
+          option("elk.padding").to_h
         end
 
         # Calculate the bounding box for a set of nodes
@@ -116,10 +127,10 @@ module Elkrb
         def calculate_bounding_box(nodes)
           return Elkrb::Geometry::Rectangle.new(0, 0, 0, 0) if nodes.empty?
 
-          min_x = nodes.map(&:x).min
-          min_y = nodes.map(&:y).min
-          max_x = nodes.map { |n| n.x + n.width }.max
-          max_y = nodes.map { |n| n.y + n.height }.max
+          min_x = nodes.map { |n| n.x || 0.0 }.min
+          min_y = nodes.map { |n| n.y || 0.0 }.min
+          max_x = nodes.map { |n| (n.x || 0.0) + (n.width || 0.0) }.max
+          max_y = nodes.map { |n| (n.y || 0.0) + (n.height || 0.0) }.max
 
           Elkrb::Geometry::Rectangle.new(
             min_x,
@@ -153,34 +164,28 @@ module Elkrb
         #
         # @param graph [Elkrb::Graph::Graph] The graph
         def apply_edge_routing(graph)
-          routing_style = get_edge_routing_style(graph)
-          route_edges(graph, nil, routing_style)
+          route_edges(graph)
         end
 
-        # Get edge routing style from graph options
-        #
-        # @param graph [Elkrb::Graph::Graph] The graph
-        # @return [String] Routing style (ORTHOGONAL, POLYLINE, SPLINES)
-        def get_edge_routing_style(graph)
-          return "ORTHOGONAL" unless graph.layout_options
-
-          style = graph.layout_options["elk.edgeRouting"] ||
-            graph.layout_options["edgeRouting"] ||
-            graph.layout_options.edge_routing ||
-            option("elk.edgeRouting") ||
-            option("edgeRouting")
-
-          style ? style.to_s.upcase : "ORTHOGONAL"
-        end
+        # Defined in EdgeRouter. Released as a protected method here, so
+        # subclasses override it and call super.
+        protected :get_edge_routing_style
 
         # Apply pre-layout constraints
         #
-        # These constraints mark nodes for special algorithm handling.
-        #
         # @param graph [Elkrb::Graph::Graph] The graph
+        # @return [Constraints::ConstraintProcessor] the processor holding the
+        #   state #enforce_post_layout_constraints needs
         def apply_pre_layout_constraints(graph)
-          processor = Constraints::ConstraintProcessor.new
+          # Only read the spacing option when a constraint needs it, so a
+          # graph without constraints never resolves an option it did not
+          # resolve before.
+          constrained = graph.children&.any?(&:constraints)
+          processor = Constraints::ConstraintProcessor.new(
+            spacing: constrained ? node_spacing : 0.0,
+          )
           processor.apply_pre_layout(graph)
+          processor
         end
 
         # Enforce post-layout constraints
@@ -188,18 +193,13 @@ module Elkrb
         # These constraints adjust positions after layout algorithm runs.
         #
         # @param graph [Elkrb::Graph::Graph] The graph
-        def enforce_post_layout_constraints(graph)
-          processor = Constraints::ConstraintProcessor.new
+        # @param processor [Constraints::ConstraintProcessor] the processor
+        #   returned by #apply_pre_layout_constraints
+        def enforce_post_layout_constraints(graph, processor)
           processor.enforce_post_layout(graph)
 
-          # Validate all constraints
-          errors = processor.validate_all(graph)
-
-          return if errors.empty?
-
-          # Log warnings for constraint violations
-          errors.each do |error|
-            warn "Layout constraint violation: #{error}"
+          processor.validate_all(graph).each do |error|
+            Elkrb.logger.warn("Layout constraint violation: #{error}")
           end
         end
       end

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

@@ -14,33 +14,60 @@ module Elkrb
         def layout_flat(graph, _options = {})
           return graph if graph.children.nil? || graph.children.empty?
 
-          # Get configuration
-          aspect_ratio = option("aspect_ratio", 1.6).to_f
-          spacing = node_spacing
-
-          # Calculate number of columns based on aspect ratio
-          num_nodes = graph.children.length
-          cols = Math.sqrt(num_nodes * aspect_ratio).ceil
-          cols = [cols, 1].max
-
-          # Find maximum node dimensions for uniform grid
-          max_width = graph.children.map(&:width).max
-          max_height = graph.children.map(&:height).max
-
-          # Position nodes in grid
-          graph.children.each_with_index do |node, i|
-            row = i / cols
-            col = i % cols
-
-            node.x = col * (max_width + spacing)
-            node.y = row * (max_height + spacing)
+          aspect_ratio = option("elk.aspectRatio")
+          spacing = option("elk.spacing.nodeNode", default: 15.0).to_f
+          nodes = graph.children.sort_by do |node|
+            (node.width || 0.0) * (node.height || 0.0)
           end
+          budget = row_budget(nodes, spacing, aspect_ratio)
+          place_rows(nodes, spacing, budget)
 
           # Apply padding and set graph dimensions
           apply_padding(graph)
 
           graph
         end
+
+        private
+
+        def row_budget(nodes, spacing, aspect_ratio)
+          area = nodes.sum do |node|
+            ((node.width || 0.0) + spacing) *
+              ((node.height || 0.0) + spacing)
+          end
+          computed = Math.sqrt(area * Math.sqrt(aspect_ratio.to_f))
+          pair_width = nodes.first(2).sum { |node| node.width || 0.0 }
+          pair_width += spacing if nodes.length > 1
+          [computed, pair_width].max
+        end
+
+        def place_rows(nodes, spacing, budget)
+          x = 0.0
+          y = 0.0
+          row_height = 0.0
+
+          nodes.each do |node|
+            width = node.width || 0.0
+            height = node.height || 0.0
+            if x.positive? && (x + width) > budget
+              x = 0.0
+              y += row_height + spacing
+              row_height = 0.0
+            end
+
+            node.x = x
+            node.y = y
+            x += width + spacing
+            row_height = [row_height, height].max
+          end
+        end
+
+        def padding
+          option(
+            "elk.padding",
+            default: { left: 15.0, top: 15.0, right: 15.0, bottom: 15.0 },
+          ).to_h
+        end
       end
     end
   end