elkrb 1.0.0 → 2.0.0

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

@@ -2,6 +2,7 @@
 
 require "set"
 require_relative "base_algorithm"
+require_relative "../node_index"
 
 module Elkrb
   module Layout
@@ -10,27 +11,45 @@ module Elkrb
       #
       # Arranges nodes in a tree structure that can handle multiple root nodes.
       class MRTree < BaseAlgorithm
+        # Both readers of the adjacency map ask for every child of the
+        # graph, sinks included, so a missing key has to answer something
+        # enumerable rather than raise or grow the map.
+        NO_CHILDREN = [].freeze
+        private_constant :NO_CHILDREN
+
         def layout_flat(graph, _options = {})
-          return graph if graph.children.empty?
+          # `layout_flat` is public and `children` really can be nil -- a
+          # deserialized graph that omits the key keeps it nil, and
+          # `BaseAlgorithm#layout` only guards its OWN dispatch with
+          # `if graph.children`. Every sibling algorithm defends itself the
+          # same way (box, fixed, force, layered, libavoid, random); mrtree
+          # was the one that did not.
+          return graph if graph.children.nil? || graph.children.empty?
+
+          index = NodeIndex.build(graph)
 
           # Identify root nodes (nodes with no incoming edges)
-          roots = find_root_nodes(graph)
+          roots = find_root_nodes(graph, index)
 
           # If no roots found, treat all nodes as roots
           roots = graph.children if roots.empty?
 
-          # Build tree structure from roots
-          trees = roots.map { |root| build_tree(root, graph) }
+          trees = build_forest(roots, graph, adjacency(graph, index))
+          level_offsets = level_offsets(trees)
 
           # Calculate positions for each tree
-          spacing_val = node_spacing
           x_offset = 0
+          # `layout_tree` returns the width it actually consumed, spacing
+          # included. Recomputing that separately is what let two trees collide:
+          # `calculate_tree_width` summed leaf widths and omitted the gap
+          # between siblings, so a tree was reported narrower than it was drawn.
           trees.each do |tree|
-            layout_tree(tree, x_offset, 0)
-            tree_width = calculate_tree_width(tree)
-            x_offset += tree_width + spacing_val
+            consumed, = layout_tree(tree, x_offset, 0, [], level_offsets)
+            x_offset += consumed
           end
 
+          orient(graph.children)
+
           # Apply padding and set graph dimensions
           apply_padding(graph)
 
@@ -39,104 +58,605 @@ module Elkrb
 
         private
 
-        def find_root_nodes(graph)
+        def find_root_nodes(graph, index)
           nodes_with_incoming = Set.new
 
           graph.edges&.each do |edge|
-            targets = edge.targets || []
-            targets.each do |target_id|
-              nodes_with_incoming.add(target_id)
+            sources = index.endpoint_nodes(edge.sources)
+
+            # Count a target as having incoming traffic only when at
+            # least one resolved source is a DIFFERENT node: a real
+            # self-loop ("p1" -> "p2" on one node) and the
+            # self-referencing leg of a mixed hyperedge
+            # (a -> [a's port, b]) are not incoming traffic from
+            # elsewhere, but a target that ALSO appears among the
+            # sources (e.g. [a, b] -> b) still has genuine incoming
+            # traffic from the other source.
+            index.endpoint_nodes(edge.targets).each do |target|
+              next unless sources.any? { |source| source != target }
+
+              nodes_with_incoming.add(target.id)
             end
           end
 
           graph.children.reject { |node| nodes_with_incoming.include?(node.id) }
         end
 
-        def build_tree(root, graph)
-          tree = {
-            node: root,
-            children: [],
-            level: 0,
-          }
+        # Child nodes per source id, resolved once for the whole graph.
+        # Rebuilding this per node would rescan every edge inside the
+        # relaxation loop.
+        #
+        # Reads `graph.edges`, matching #find_root_nodes, NOT `index.edges`.
+        # The index folds in the edges declared on childless top-level nodes,
+        # so it is a strict superset: reading it here while root finding reads
+        # the narrower set would let a node whose only incoming edge sits on a
+        # sibling leaf be a root AND somebody's child at the same time.
+        #
+        # Ids identify nodes here where #find_root_nodes compares objects. The
+        # two agree: NodeIndex keeps ids unique within a level and answers the
+        # same object for the same id.
+        def adjacency(graph, index)
+          map = {}
+
+          (graph.edges || []).each do |edge|
+            targets = index.endpoint_nodes(edge.targets)
+
+            index.endpoint_nodes(edge.sources).each do |source|
+              # A hyperedge can target one of its source's own ports
+              # alongside a real child (a -> [a's port, b]). Resolving that
+              # port back to the source would make the node its own child,
+              # and stepping down it would let the node keep deepening its
+              # own level until it hit the relaxation bound.
+              children = targets.reject { |target| target.id == source.id }
+              (map[source.id] ||= []).concat(children)
+            end
+          end
+
+          map.each_value { |children| children.uniq!(&:id) }
+          # Set AFTER the loop above, not before it. With the default already
+          # in place `(map[source.id] ||= [])` reads the frozen constant, finds
+          # it truthy, and concats into it — FrozenError on the first edge.
+          map.default = NO_CHILDREN
+          map
+        end
+
+        # Every child has to end up in some tree. A component that is wholly
+        # cyclic (a -> b -> a) contains no root, so it is never reached from
+        # the graph's roots and its nodes keep nil coordinates until padding
+        # trips over them. Whenever a pass leaves nodes unplaced, seed one of
+        # them as a fallback root and keep going.
+        def build_forest(roots, graph, adjacent)
+          # A node reachable by two paths belongs at the DEEPER one, or it
+          # ends up above its own parent. Levels are settled for the whole
+          # graph before any tree is built, so placement order stops mattering.
+          # That is a DAG guarantee: a cyclic component gets bounded fallback
+          # numbers instead, and #build_subtree's floor is what re-orders those.
+          levels = {}
+          seeds = roots.dup
+
+          # Relaxation is scoped to ONE component at a time. It used to run
+          # graph-wide per seed, and the level bound was the whole graph's node
+          # count, so a two-node cycle kept incrementing a <-> b until it hit
+          # that bound: O(n) passes over O(n) nodes for every component, which
+          # is cubic. Measured on disjoint two-cycles before this change --
+          # 160 nodes 0.45s, 320 nodes 3.21s, 480 nodes 10.58s.
+          members = components(graph, adjacent)
+
+          relax_component_of(roots, members, adjacent, levels)
+
+          # Walk the children once. Rescanning for the first unlevelled node on
+          # every iteration was itself quadratic.
+          graph.children.each do |node|
+            next if levels.key?(node.id)
+
+            seeds << node
+            relax_component_of([node], members, adjacent, levels)
+          end
+
+          # `placed` doubles as the walk's visited set, so a later tree cannot
+          # reach back into a node an earlier tree already owns — placing a
+          # node twice lets the second placement win and drags it above its own
+          # parent. Nothing reads `placed` mid-walk except the walk itself.
+          placed = Set.new
+          seeds.filter_map do |seed|
+            next if placed.include?(seed.id)
+
+            build_subtree(seed, adjacent, placed, levels, 0)
+          end
+        end
+
+        # Undirected connected components, computed once. Returns node id ->
+        # the array of nodes sharing its component, so a relaxation can bound
+        # itself by its own component's size instead of the whole graph's.
+        def components(graph, adjacent)
+          neighbours = undirected(graph, adjacent)
+
+          by_id = {}
+          graph.children.each do |node|
+            next if by_id.key?(node.id)
+
+            group = reachable_from(node, neighbours)
+            group.each { |member| by_id[member.id] = group }
+          end
+
+          by_id
+        end
+
+        # An edge constrains level in one direction but joins a component in
+        # both, so connectivity is walked undirected.
+        def undirected(graph, adjacent)
+          neighbours = Hash.new { |hash, key| hash[key] = [] }
 
-          # Find children (nodes connected by outgoing edges)
-          children = find_children(root, graph)
-          tree[:children] = children.map do |child|
-            build_subtree(child, graph, 1)
+          graph.children.each do |node|
+            adjacent[node.id].each do |child|
+              neighbours[node.id] << child
+              neighbours[child.id] << node
+            end
+          end
+
+          neighbours
+        end
+
+        def reachable_from(node, neighbours)
+          group = []
+          stack = [node]
+          seen = { node.id => true }
+
+          until stack.empty?
+            current = stack.pop
+            group << current
+            neighbours[current.id].each do |other|
+              next if seen[other.id]
+
+              seen[other.id] = true
+              stack << other
+            end
+          end
+
+          group
+        end
+
+        # Seed the given nodes at level 0 and relax only the components they
+        # belong to, bounded by those components' sizes. Seeds may span
+        # SEVERAL components -- the roots do on a forest -- so the groups are
+        # collected per component and each is relaxed once, carrying its own
+        # seeds into the relaxation as its starting front.
+        #
+        # `compare_by_identity` is load-bearing. The values are arrays of
+        # graph nodes, and lutaml-model gives those VALUE equality: two
+        # distinct components holding look-alike nodes are `==` and hash the
+        # same, so an ordinary Hash would merge them and relax one of them
+        # against the other's bound.
+        #
+        # A seed with no component is skipped, which cannot happen: `members`
+        # is built from the same `graph.children` the seeds come from. It is
+        # written this way so a future disagreement between the two skips
+        # that seed rather than raising mid-layout.
+        def relax_component_of(seeds, members, adjacent, levels)
+          seeds.each { |seed| levels[seed.id] = 0 }
+
+          per_component = {}.compare_by_identity
+          seeds.each do |seed|
+            group = members[seed.id]
+            next if group.nil?
+
+            (per_component[group] ||= []) << seed
+          end
+
+          per_component.each do |group, group_seeds|
+            relax_levels(group, group_seeds, adjacent, levels)
+          end
+
+          nil
+        end
+
+        # On a DAG this settles on the LONGEST path to each node, which is what
+        # puts a node reachable by two routes below its deepest parent. Walking
+        # every simple path to find that is factorial — a complete 8-node
+        # DIGRAPH (every node pointing at every other, not a simple cycle)
+        # took 2.5s and each extra node multiplied it by roughly ten. Relax
+        # instead: a longest path visits each node at most once, so a node
+        # re-queued whenever its own level moves settles every level a DAG
+        # can produce.
+        #
+        # A cyclic component has no longest path, so what its nodes get here is
+        # a bounded fallback number rather than a depth — `max_level` stops it
+        # climbing, it does not make it mean anything. It is also the ONLY
+        # thing that stops it: the sweep form had a pass count to fall out
+        # of as well, and the worklist does not. Measured with `max_level`
+        # removed, a six-node complete digraph does not finish in five
+        # seconds; with it, it lays out in seven rows. Ordering inside such a
+        # component is restored afterwards by #build_subtree's floor.
+        #
+        # `nodes` is ONE component, so the level ceiling is that component's
+        # size. It used to be the whole graph's node count, which is what let
+        # a two-node cycle climb for O(n) passes.
+        #
+        # The relaxation is a WORKLIST, not repeated full sweeps of the
+        # component. Only a node whose own level just moved can move its
+        # children's, so re-reading every settled node each time is pure
+        # waste -- and the fallback loop in #build_forest calls this once per
+        # unlevelled node, so that waste multiplied. Several rootless cycles
+        # sharing ONE component (a pile of two-cycles all pointing at one
+        # sink) made every seed re-sweep the whole component, which is cubic:
+        # measured before this change at 0.16s for 80 nodes, 1.03s for 160,
+        # 2.75s for 240 and past five seconds at 320.
+        #
+        # WHAT THIS CHANGED, measured over 3000 random graphs. Every ACYCLIC
+        # graph lays out byte-identically: on a DAG both forms reach the same
+        # longest-path levels, and 525 of 525 agreed. All 571 differences are
+        # CYCLIC, where a level is a bounded fallback number rather than a
+        # depth (see the comment above) -- and the difference is that the
+        # sweep stopped after `component size` passes whether or not it had
+        # settled, so what it produced depended on the order the component's
+        # nodes happened to come out of the DFS. Reversing that order in
+        # place changed 710 of 3000 layouts under the sweep and 0 of 3000
+        # under the worklist, which runs to the fixpoint every time.
+        #
+        # Mutates `levels` in place and returns nothing useful.
+        def relax_levels(nodes, seeds, adjacent, levels)
+          max_level = nodes.size
+          queue = seeds.dup
+
+          until queue.empty?
+            node = queue.shift
+            candidate = levels[node.id] + 1
+            next if candidate > max_level
+
+            adjacent[node.id].each do |child|
+              next if candidate <= (levels[child.id] || -1)
+
+              levels[child.id] = candidate
+              queue << child
+            end
+          end
+
+          nil
+        end
+
+        # `visited` is one mutable set for the whole walk, not a per-path copy.
+        # Copying it per path means a node reachable by many routes is expanded
+        # once per route, which is factorial on a dense graph — and it would
+        # place that node more than once anyway.
+        #
+        # `floor` is the level this node may not sit above: one below its parent
+        # in the tree being built. A cyclic component gets bounded fallback
+        # levels rather than path depths, so a back edge can hand a node a level
+        # deeper than its own child's and draw the parent underneath it. Taking
+        # the floor forces every edge the forest actually picked to point down.
+        # The edge that CLOSES a cycle is not one of those, and still points
+        # upward — no tree can honour it, so it stays a violation.
+        #
+        # A floored level can exceed the relaxation bound: r0 -> a -> b -> c
+        # with c -> a closing it puts c at level 6 across four nodes. Cyclic
+        # components therefore come out taller than they need to be.
+        # Use an explicit stack because the walk's depth is controlled by the
+        # input graph, not by this implementation.
+        def build_subtree(root, adjacent, visited, levels, floor)
+          visited << root.id
+          tree = subtree_node(root, levels, floor)
+          stack = [[root, tree]]
+
+          until stack.empty?
+            node, node_tree = stack.pop
+            children = adjacent[node.id]
+                       .reject { |child| visited.include?(child.id) }
+            children.each { |child| visited << child.id }
+
+            child_floor = node_tree[:level] + 1
+            child_trees = children.map do |child|
+              subtree_node(child, levels, child_floor)
+            end
+            node_tree[:children] = child_trees
+            children.zip(child_trees).reverse_each { |pair| stack << pair }
           end
 
           tree
         end
 
-        def build_subtree(node, graph, level)
-          tree = {
+        def subtree_node(node, levels, floor)
+          {
             node: node,
             children: [],
-            level: level,
+            level: [levels.fetch(node.id), floor].max,
           }
+        end
 
-          children = find_children(node, graph)
-          tree[:children] = children.map do |child|
-            build_subtree(child, graph, level + 1)
+        # `placed` collects every node of the tree being laid out, in post
+        # order, appended exactly once. A subtree therefore occupies a
+        # CONTIGUOUS slice, and its parent can read or shift that slice by
+        # index without walking the tree again.
+        #
+        # It matters: reading the extent by re-walking the subtree at every
+        # level is quadratic on a deep tree. Instrumented on a chain before
+        # this change -- 20,099 visits for 200 nodes and 320,399 for 800.
+        # That is (n+2)(n-1)/2, not n^2/2; the shape is what matters, and
+        # doubling n multiplies the visits by four. This walk is iterative
+        # because its depth is likewise controlled by the input graph.
+        LayoutFrame = Struct.new(:tree, :x_offset, :y_offset, :start,
+                                 :child_x, :left, :right, :index)
+        private_constant :LayoutFrame
+
+        def layout_tree(tree, x_offset, y_offset, placed = [], offsets = {})
+          if tree[:children].empty?
+            return place_leaf(tree, x_offset, y_offset, placed, offsets)
           end
 
-          tree
+          stack = [layout_frame(tree, x_offset, y_offset, placed.size)]
+          result = nil
+
+          until stack.empty?
+            frame = stack.last
+            if frame.index < frame.tree[:children].size
+              advance_layout(frame, stack, placed, offsets)
+            else
+              stack.pop
+              result = finish_layout(frame, stack.last, placed, offsets)
+            end
+          end
+
+          result
         end
 
-        def find_children(node, graph)
-          children = []
-          edges = graph.edges || []
+        def layout_frame(tree, x_offset, y_offset, start)
+          LayoutFrame.new(tree, x_offset, y_offset, start,
+                          x_offset, nil, nil, 0)
+        end
 
-          edges.each do |edge|
-            sources = edge.sources || []
-            targets = edge.targets || []
+        def advance_layout(frame, stack, placed, offsets)
+          child = frame.tree[:children][frame.index]
+          frame.index += 1
 
-            next unless sources.include?(node.id)
+          if child[:children].empty?
+            extend_layout(frame,
+                          *place_leaf(child, frame.child_x, frame.y_offset,
+                                      placed, offsets))
+          else
+            stack << layout_frame(child, frame.child_x, frame.y_offset,
+                                  placed.size)
+          end
+        end
 
-            targets.each do |target_id|
-              child = graph.children.find { |n| n.id == target_id }
-              children << child if child
-            end
+        def finish_layout(frame, parent, placed, offsets)
+          centre_over_children(frame.tree, frame.y_offset, offsets)
+          placed << frame.tree[:node]
+          result = settle_subtree(frame.tree[:node], placed, frame.start,
+                                  frame.x_offset, [frame.left, frame.right])
+          extend_layout(parent, *result) if parent
+          result
+        end
+
+        def extend_layout(frame, consumed, left, right)
+          frame.child_x += consumed
+          frame.left = left if frame.left.nil? || left < frame.left
+          frame.right = right if frame.right.nil? || right > frame.right
+        end
+
+        # The width CONSUMED, measured from where the nodes actually landed.
+        # `child_x` alone is not it: it accounts only for the children's
+        # allocation, and a node WIDER than its children protrudes past them
+        # on both sides. A 200px parent over two 10px children reported 60
+        # while occupying 200, and the next tree started 60px inside it.
+        # Centring can also push the parent left of `x_offset`, so the
+        # subtree is nudged back before its extent is read.
+        #
+        # Only when the parent actually protrudes LEFT does this touch the
+        # subtree again, and then only that subtree's own slice. Reading the
+        # extent by re-walking every level instead cost n^2/2 node visits on
+        # a deep tree -- measured on a chain: 320,399 visits for 800 nodes,
+        # now 0, and the layout went from 0.443s to 0.244s.
+        def settle_subtree(node, placed, start, x_offset, extent)
+          left, right = extent
+          own_right = node.x + (node.width || 0.0)
+          left = node.x if node.x < left
+          right = own_right if own_right > right
+
+          if left < x_offset
+            shift = x_offset - left
+            shift_slice(placed, start, shift)
+            left += shift
+            right += shift
           end
 
-          children
+          [right - x_offset + node_spacing, left, right]
         end
 
-        def layout_tree(tree, x_offset, y_offset)
+        # A leaf sits where it was told to, and occupies exactly its own box.
+        def place_leaf(tree, x_offset, y_offset, placed, offsets)
           node = tree[:node]
-          spacing_val = node_spacing
-          level_height = 80.0
+          node.x = x_offset
+          node.y = y_offset + offsets.fetch(tree[:level], 0.0)
+          placed << node
+          width = node.width || 0.0
 
-          if tree[:children].empty?
-            # Leaf node
-            node.x = x_offset
-            node.y = y_offset + (tree[:level] * level_height)
-            return node.width + spacing_val
+          [width + node_spacing, node.x, node.x + width]
+        end
+
+        # Centres a node over the children already placed beneath it.
+        def centre_over_children(tree, y_offset, offsets)
+          node = tree[:node]
+          first_child = tree[:children].first[:node]
+          last_child = tree[:children].last[:node]
+          last_child_width = last_child.width || 0.0
+          center_x = (first_child.x + last_child.x + last_child_width) / 2.0
+
+          node.x = center_x - ((node.width || 0.0) / 2.0)
+          node.y = y_offset + offsets.fetch(tree[:level], 0.0)
+        end
+
+        # Every row starts below the tallest node in the preceding row. This
+        # preserves the tree's level/breadth geometry without assuming a node
+        # height, and makes the configured node spacing the actual gap.
+        def level_offsets(trees)
+          heights = Hash.new(0.0)
+          stack = trees.dup
+
+          until stack.empty?
+            tree = stack.pop
+            level = tree[:level]
+            heights[level] = [heights[level], tree[:node].height || 0.0].max
+            stack.concat(tree[:children])
           end
 
-          # Layout children first
-          child_x = x_offset
-          tree[:children].each do |child_tree|
-            width = layout_tree(child_tree, child_x, y_offset)
-            child_x += width
+          offset = 0.0
+          (0..(heights.keys.max || 0)).to_h do |level|
+            current = offset
+            offset += heights[level] + node_spacing
+            [level, current]
           end
+        end
 
-          # Position this node centered above children
-          first_child = tree[:children].first[:node]
-          last_child = tree[:children].last[:node]
+        # Layout is calculated once in DOWN's (breadth, level) coordinate
+        # frame. Other directions are rotations/mirrors of that same shape;
+        # apply_padding normalises the resulting negative coordinates.
+        def orient(nodes)
+          direction = option("elk.direction", default: "DOWN").to_s.upcase
+
+          case direction
+          when "RIGHT"
+            nodes.each { |node| node.x, node.y = node.y, node.x }
+          when "UP"
+            nodes.each { |node| node.y = -node.y - (node.height || 0.0) }
+          when "LEFT"
+            nodes.each do |node|
+              breadth = node.x
+              node.x = -node.y - (node.width || 0.0)
+              node.y = breadth
+            end
+          end
+        end
+
+        # ELK's MRTree layout uses 20px padding even though the shared core
+        # registry default is 12px. An explicit graph/call option still wins.
+        def padding
+          option(
+            "elk.padding",
+            default: { left: 20.0, top: 20.0, right: 20.0, bottom: 20.0 },
+          ).to_h
+        end
+
+        # MRTree connects a parent's side to the centre of each child's near
+        # side. Sibling edges receive distinct, evenly spaced attachment
+        # points, matching ELK's tree routing and keeping every endpoint on a
+        # node border.
+        def apply_edge_routing(graph)
+          super
+          index = NodeIndex.build(graph)
+          outgoing = Hash.new { |hash, key| hash[key] = [] }
+
+          (graph.edges || []).each do |edge|
+            connection = tree_connection(edge, index)
+            next unless connection
+
+            outgoing[connection[1].id] << connection
+          end
+
+          outgoing.each_value do |entries|
+            entries.each_with_index do |connection, position|
+              route_tree_edge(
+                connection, position + 1, entries.size + 1, graph
+              )
+            end
+          end
+        end
 
-          center_x = (first_child.x + last_child.x + last_child.width) / 2.0
-          node.x = center_x - (node.width / 2.0)
-          node.y = y_offset + (tree[:level] * level_height)
+        def tree_connection(edge, index)
+          source = index.endpoint_nodes(edge.sources).first
+          target = index.endpoint_nodes(edge.targets).first
+          return unless source && target && source.id != target.id
 
-          # Return total width
-          last_child.x + last_child.width - x_offset + spacing_val
+          [edge, source, target]
         end
 
-        def calculate_tree_width(tree)
-          return tree[:node].width if tree[:children].empty?
+        def route_tree_edge(connection, position, denominator, graph)
+          edge, source, target = connection
+          fraction = position.to_f / denominator
+          direction = option("elk.direction", default: "DOWN").to_s.upcase
+          direction = "DOWN" if direction == "UNDEFINED"
 
-          tree[:children].sum { |child| calculate_tree_width(child) }
+          start, finish, bend = tree_edge_points(
+            source, target, direction, fraction
+          )
+          start = tree_endpoint_position(
+            edge.sources.first, source, start, :outgoing
+          )
+          finish = tree_endpoint_position(
+            edge.targets.first, target, finish, :incoming
+          )
+          section = reset_section(edge, graph)
+          section.start_point = start
+          section.end_point = finish
+          section.bend_points = [bend]
+          connection.first.container = graph.id
+        end
+
+        def tree_edge_points(source, target, direction, fraction)
+          case direction
+          when "RIGHT"
+            start = Geometry::Point.new(
+              x: source.x + node_width(source),
+              y: source.y + (node_height(source) * fraction),
+            )
+            finish = Geometry::Point.new(
+              x: target.x,
+              y: target.y + (node_height(target) / 2.0),
+            )
+            bend = Geometry::Point.new(x: start.x + 3.0, y: start.y)
+          when "UP"
+            start = Geometry::Point.new(
+              x: source.x + (node_width(source) * fraction),
+              y: source.y,
+            )
+            finish = Geometry::Point.new(
+              x: target.x + (node_width(target) / 2.0),
+              y: target.y + node_height(target),
+            )
+            bend = Geometry::Point.new(x: start.x, y: start.y - 3.0)
+          when "LEFT"
+            start = Geometry::Point.new(
+              x: source.x,
+              y: source.y + (node_height(source) * fraction),
+            )
+            finish = Geometry::Point.new(
+              x: target.x + node_width(target),
+              y: target.y + (node_height(target) / 2.0),
+            )
+            bend = Geometry::Point.new(x: start.x - 3.0, y: start.y)
+          else
+            start = Geometry::Point.new(
+              x: source.x + (node_width(source) * fraction),
+              y: source.y + node_height(source),
+            )
+            finish = Geometry::Point.new(
+              x: target.x + (node_width(target) / 2.0),
+              y: target.y,
+            )
+            bend = Geometry::Point.new(x: start.x, y: start.y + 3.0)
+          end
+
+          [start, finish, bend]
+        end
+
+        def tree_endpoint_position(endpoint_id, node, node_point, direction)
+          return node_point unless find_port_by_id(endpoint_id, node)
+
+          get_port_position(endpoint_id, node, direction)
+        end
+
+        def node_width(node)
+          node.width || 0.0
+        end
+
+        def node_height(node)
+          node.height || 0.0
+        end
+
+        def shift_slice(placed, start, shift)
+          index = start
+          while index < placed.size
+            placed[index].x += shift
+            index += 1
+          end
         end
       end
     end