ea 0.6.131 → 0.6.133

data/lib/ea/sources/xmi/diagram_builder.rb

@@ -9,6 +9,8 @@ module Ea
       # SOID/EOID, EDGE, label boxes) when present. Falls back to
       # the UML-DI owned_element bounds otherwise.
       class DiagramBuilder
+        autoload :UmldiEdges, "ea/sources/xmi/diagram_builder/umldi_edges"
+
         attr_reader :root, :xmi_path
 
         def initialize(root, xmi_path = nil)
@@ -53,6 +55,7 @@ module Ea
             bounds: canvas_bounds(placed_elements),
             style: style_for(ext_diagram),
             style_ex: style_ex_for(ext_diagram),
+            show_notes: style_ex_for(ext_diagram).to_s.include?("ShowNotes=1"),
             elements: build_elements(placed_elements, id, umldi_keywords),
             connectors: build_connectors(placed_connectors,
                                           placed_elements, id),
@@ -144,20 +147,23 @@ module Ea
             acc[pe.style.duid] = pe if pe.style.duid
           end
 
-          placed_connectors.map { |p| build_connector(p, by_duid, owner_id) }
+          placed_connectors.each_with_index.map do |placed, index|
+            build_connector(placed, by_duid, owner_id, index)
+          end
         end
 
-        def build_connector(placed, by_duid, owner_id)
+        def build_connector(placed, by_duid, owner_id, rank)
           geom = placed.geometry
           style = placed.style
           source = by_duid[style.soid]
           target = by_duid[style.eoid]
-          waypoints = compute_waypoints(geom, source, target)
           ext_meta = connector_meta(placed.subject)
+          route = connector_route(placed, source, target, owner_id, ext_meta[:ea_type])
           Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic_id(owner_id, "conn", placed.subject),
             diagram_id: owner_id,
             relationship_ref: placed.subject,
+            paint_order: [rank],
             source_duid: style.soid,
             target_duid: style.eoid,
             source_element_ref: source && synthetic_element_id(owner_id, source),
@@ -166,8 +172,8 @@ module Ea
             target_edge: geom.edge,
             connector_type: ext_meta[:ea_type],
             direction: ext_meta[:direction],
-            waypoints: waypoints,
-            style: {},
+            waypoints: route[:waypoints],
+            style: route[:style],
             line_color: style.color,
             line_width: style.line_width,
             hidden: style.hidden,
@@ -211,11 +217,35 @@ module Ea
           IdNormalizer.synthetic_id(owner_id, "elem", placed.subject)
         end
 
-        def compute_waypoints(geom, source, target)
+        def connector_route(placed, source, target, owner_id, type)
+          native = umldi_waypoints(owner_id, placed) if placed.geometry.bend_points.to_a.empty?
+          points = native || compute_waypoints(placed.geometry, source, target,
+                                               style: placed.style, connector_type: type)
+          native ||= umldi_waypoints(owner_id, placed) if points.empty?
+          { waypoints: native || points, style: native ? { umldi_route: true } : {} }
+        end
+
+        # EA's unique exported edge supplies bendless routes and recovers
+        # routes whose placement endpoints cannot be resolved.
+        def umldi_waypoints(diagram_id, placed)
+          return unless xmi_path
+
+          route = umldi_edges.route_for(diagram_id, placed.subject)
+          route&.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
+        end
+
+        def umldi_edges
+          @umldi_edges ||= UmldiEdges.new(xmi_path)
+        end
+
+        def compute_waypoints(geom, source, target, style:, connector_type:)
           src_bounds = bounds_from_placed(source)
           tgt_bounds = bounds_from_placed(target)
           return [] unless src_bounds && tgt_bounds
 
+          stored = stored_route(geom, style, connector_type, src_bounds, tgt_bounds)
+          return stored if stored
+
           router = Ea::Svg::ConnectorRouter.new(
             source_bounds: src_bounds,
             target_bounds: tgt_bounds,
@@ -229,6 +259,27 @@ module Ea
           end
         end
 
+        # Stored bends are routed by StoredRoute where a QEA rule claims
+        # them; anything else keeps the generic router.
+        def stored_route(geom, style, connector_type, src_bounds, tgt_bounds)
+          offsets = { source: [geom.sx, geom.sy], target: [geom.ex, geom.ey] }
+          points = StoredRoute.new.waypoints(
+            link: StoredRoute::Link.new(style.raw, geom.path.to_s.tr("$", ";"), offset_geometry(geom)),
+            connector_type: connector_type, source: src_bounds, target: tgt_bounds,
+            bends: geom.bend_points.to_a, offsets: offsets, edge: geom.edge
+          )
+          return unless points
+
+          points.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        def offset_geometry(geom)
+          { "SX" => geom.sx, "SY" => geom.sy, "EX" => geom.ex, "EY" => geom.ey }
+            .filter_map { |key, value| "#{key}=#{value};" if value }.join
+        end
+
         def bounds_from_placed(placed)
           return nil unless placed
 
@@ -264,12 +315,16 @@ module Ea
 
           label_boxes.transform_values do |box|
             {
-              "cx" => box.cx, "cy" => box.cy,
               "ox" => box.ox, "oy" => box.oy,
+              "cx" => box.cx, "cy" => box.cy,
+              "hidden" => box.hidden,
               "bold" => box.bold,
               "italic" => box.italic,
               "underline" => box.underline,
-              "align" => box.align
+              "color" => box.color,
+              "alignment" => box.align,
+              "direction" => box.direction,
+              "rotation" => box.rotation
             }
           end
         end

data/lib/ea/sources/xmi/extension_geometry_parser.rb

@@ -38,8 +38,9 @@ module Ea
         end
 
         # EA's Path= field uses the format `x1:y1$x2:y2$...` where
-        # each pair is a bend point. Coordinates are absolute pixel
-        # positions on the diagram canvas.
+        # each pair is a bend point. EA stores Y negated (as in QEA
+        # t_diagramlinks.Path); the result uses screen-positive Y,
+        # like element bounds.
         def parse_bend_path(raw)
           return [] if raw.nil? || raw.empty?
 
@@ -49,7 +50,7 @@ module Ea
             x_str, y_str = pair.split(":", 2)
             x = int(x_str)
             y = int(y_str)
-            [x, y] if x && y
+            [x, -y] if x && y
           end
         end
 
@@ -72,7 +73,7 @@ module Ea
         end
 
         def extract_label_boxes(geometry_string)
-          geometry_string.to_s.scan(/\$?([A-Z]{3})=((?:[A-Za-z]{1,4}=-?\d+:)+)/).each_with_object({}) do |(key, body), acc|
+          geometry_string.to_s.scan(/\$?([A-Z]{3})=((?:[A-Za-z]{1,4}=-?\d+:?)+)/).each_with_object({}) do |(key, body), acc|
             sym = key.downcase.to_sym
             next unless LABEL_BOX_KEYS.include?(sym)
             next if body.nil? || body.empty?
@@ -98,6 +99,7 @@ module Ea
             italic: hash["ITA"] == 1,
             underline: hash["UND"] == 1,
             hidden: hash["HDN"] == 1,
+            color: hash["CLR"],
             align: hash["ALN"],
             direction: hash["DIR"],
             rotation: hash["ROT"]
@@ -114,7 +116,7 @@ module Ea
 
         LabelBox = Struct.new(
           :cx, :cy, :ox, :oy,
-          :bold, :italic, :underline, :hidden,
+          :bold, :italic, :underline, :hidden, :color,
           :align, :direction, :rotation,
           keyword_init: true
         )

data/lib/ea/sources/xmi/relationship_builder.rb

@@ -49,7 +49,7 @@ module Ea
           id = IdNormalizer.from_xmi_id(element.id)
           {
             id: id,
-            name: element.name || element.type&.split(":")&.last&.downcase,
+            name: element.name,
             qualified_name: element.name,
             annotations: AnnotationBuilder.from_element(element, id)
           }

data/lib/ea/sources/xmi/stored_route.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Routes an XMI connector the way the QEA source does: the same
+      # center-ray ports and the same QEA route helpers, over the same
+      # inputs (link style, bends in `x:y;` form, connector type, endpoint
+      # boxes). Returns nil where QEA would fall back to bare SX/SY deltas,
+      # which the generic router keeps handling.
+      class StoredRoute < Qea::DiagramBuilder
+        Link = Struct.new(:style, :path, :geometry)
+        Connector = Struct.new(:connector_type)
+
+        def initialize
+          super(nil)
+        end
+
+        def waypoints(link:, connector_type:, source:, target:, bends:, offsets:, edge: nil)
+          connector = Connector.new(connector_type)
+          ports = { source: port_for(source, offsets[:source]), target: port_for(target, offsets[:target]) }
+          edge ||= 0
+          points = initial_points(link, connector, source, target, bends, ports, edge)
+          return unless points
+
+          finish(points, link, connector, source, target, bends, ports, offsets, edge)
+        end
+
+        private
+
+        # Placements here are already Ea::Model::Bounds.
+        def bounds_from_rect(bounds)
+          bounds
+        end
+
+        def ported?(offset)
+          offset.none?(&:nil?) && offset.any?(&:nonzero?)
+        end
+
+        def port_for(box, offset)
+          ray_port(box, offset) if ported?(offset)
+        end
+
+        def initial_points(link, connector, source, target, bends, ports, edge)
+          src = ports[:source] || element_edge_point(source, :source, edge)
+          tgt = ports[:target] || element_edge_point(target, :target, edge)
+          if Qea::DiagramStyleParser.parse(link.style)[:mode] == "1"
+            [src, tgt]
+          elsif edge == 2 && ports.values.all? && !valid_tree_path?(bends, source)
+            [src, [tgt[0], src[1]], tgt]
+          elsif edge == 2 && bends.size == 1
+            tree_points(source, target, bends.first)
+          elsif bends.any?
+            bent_points(src, bends, tgt, link, connector, source, target)
+          elsif ports.values.any?
+            [src, tgt]
+          end
+        end
+
+        def tree_points(src, tgt, bend)
+          target_y = tgt.y + tgt.height <= src.y ? tgt.y + tgt.height : tgt.y
+          [[src.x + src.width, bend[1]], [bend[0], bend[1]], [bend[0], target_y]]
+        end
+
+        def bent_points(src, bends, tgt, link, connector, source, target)
+          points = [src, *bends, tgt]
+          redock_parent_above(points, link, source, target) if connector.connector_type == "Generalization"
+          points
+        end
+
+        def finish(points, link, connector, source, target, bends, ports, offsets, edge)
+          tree_route = stored_tree_route(points, link, connector, source, target, ports)
+          if tree_route
+            points = tree_route
+          elsif %w[Association Aggregation].include?(connector.connector_type) && edge != 2
+            points = facing(points, link, connector, source, target, bends)
+          end
+          points = level_entry_route(points, link, connector, source, target) if bends.any? && !tree_route
+          points = drop_zero_length_tree_segments(points, link)
+          empty_path_ray(points, link, connector, source, target, bends, ports, offsets, edge)
+        end
+
+        # An empty Path has no authored corner to keep: a computed EDGE2 jog
+        # between ports that face across a gap becomes the straight port line.
+        def empty_path_ray(points, link, connector, source, target, bends, ports, offsets, edge)
+          style = Qea::DiagramStyleParser.parse(link.style)
+          return points unless %w[Generalization Aggregation].include?(connector.connector_type) &&
+                               points.size == 3 && bends.empty? && edge == 2 && ports.values.all? &&
+                               style[:mode] == "3" && style[:lwidth] == "2" && !style[:tree]
+          return points unless ray_gap?(source, target, offsets)
+
+          ports.values_at(:source, :target)
+        end
+
+        def ray_gap?(source, target, offsets)
+          return false unless source.x + source.width < target.x
+
+          [[source, offsets[:source]], [target, offsets[:target]]].all? do |box, (x, y)|
+            within_height?(stored_ray_origin(box, x, y).y, source) &&
+              within_height?(stored_ray_origin(box, x, y).y, target)
+          end
+        end
+
+        def stored_tree_route(points, link, connector, source, target, ports)
+          stored_square_route(link, connector, source, target) ||
+            stored_stair_route(link, connector, source, target) ||
+            stored_lateral_route(link, connector, source, target, ported: ports.values.all?) ||
+            derived_lateral_route(link, connector, source, target) ||
+            horizontal_tree_route(points, link, connector, source, target)
+        end
+
+        def facing(points, link, connector, source, target, bends)
+          stored_tree = preserve_stored_tree?(points, link, connector, source, target)
+          unless stored_tree || level_corner_route?(points, link, connector, source, target)
+            points = facing_edge_route(points, source, target)
+          end
+          if connector.connector_type == "Aggregation" && bends.any? && points.size >= 4 &&
+             (generalization_outline_offset(link, points.size) == 1 ||
+              (stored_tree && flush_width_zero_tree?(link)))
+            redock_parent_above(points, link, source, target, strict: true)
+          end
+          redock_vertical_tree_trunk(points, link, connector, source, target) if bends.any?
+          points
+        end
+
+        # EA's SX/SY (EX/EY) point from the box center toward the port,
+        # y up; the port is where that ray leaves the box.
+        def ray_port(bounds, offset)
+          dx = offset[0].to_f
+          dy = -offset[1].to_f
+          center_x = bounds.x + bounds.width / 2.0
+          center_y = bounds.y + bounds.height / 2.0
+          t = [ray_scale(dx, bounds.x, bounds.width, center_x),
+               ray_scale(dy, bounds.y, bounds.height, center_y)].min
+          [(center_x + t * dx).round, (center_y + t * dy).round]
+        end
+
+        def ray_scale(delta, origin, length, center)
+          return Float::INFINITY if delta.zero?
+
+          ((delta.positive? ? origin + length : origin) - center) / delta
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/xmi.rb

@@ -28,6 +28,7 @@ module Ea
       autoload :NoteBuilder, "ea/sources/xmi/note_builder"
       autoload :StereotypeBuilder, "ea/sources/xmi/stereotype_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"
+      autoload :StoredRoute, "ea/sources/xmi/stored_route"
       autoload :ExtensionTypes, "ea/sources/xmi/extension_types"
       autoload :ExtensionElements, "ea/sources/xmi/extension_elements"
       autoload :ExtensionGeometryParser, "ea/sources/xmi/extension_geometry_parser"

data/lib/ea/svg/ea_emitter/connector_bridges.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Bridges decorate resolved render paths; stored routes and marker seats
+      # remain centerlines. The connector's stored order key (reproducing EA's
+      # exported link order), rather than style group order, determines which
+      # connector passes over a crossing.
+      class ConnectorBridges
+        RADIUS = 6
+
+        def initialize(_diagram, routes)
+          @routes = routes.map { |connector, points| [connector, points, priority_for(connector)] }
+        end
+
+        def path_for(connector, points)
+          priority = priority_for(connector)
+          return centerline(connector, points) unless priority
+
+          segments = points.each_cons(2).map do |first, last|
+            crossings_for(connector, priority, first, last)
+          end
+          return centerline(connector, points) if segments.all?(&:empty?)
+
+          serialize(points, segments)
+        end
+
+        private
+
+        def centerline(connector, points)
+          seats = points.map { |point| coordinates(point) }
+          # Direct lines retain EA's target-first repeat and source-first model.
+          if points.size == 2 && direct?(connector)
+            "M #{seats.last} L #{seats.first} M #{seats.last}"
+          else
+            "M #{seats.join(" L ")}"
+          end
+        end
+
+        def direct?(connector)
+          style = connector.style || {}
+          style.key?(:direct) || style.key?("direct")
+        end
+
+        def serialize(points, segments)
+          commands = ["M #{coordinates(points.first)}"]
+          points.each_cons(2).with_index do |(first, last), index|
+            segments[index].each do |crossing|
+              commands.concat(arc_commands(first, last, crossing))
+            end
+            commands << "L #{coordinates(last)}"
+          end
+          commands.join(" ")
+        end
+
+        # nil or empty: no bridge decision for this connector.
+        def priority_for(connector)
+          connector.paint_order if connector.paint_order&.any?
+        end
+
+        def crossings_for(connector, priority, first, last)
+          axis = axis_for(first, last)
+          return [] unless axis
+
+          crossings = lower_routes(connector, priority).flat_map do |_partner, points, _order|
+            points.each_cons(2).filter_map do |start, finish|
+              crossing(first, last, start, finish, axis)
+            end
+          end
+          separate_crossings(crossings, axis).sort_by { |point| (point[axis] - first[axis]).abs }
+        end
+
+        # The order key is only proven across different start placements, so
+        # connectors leaving the same placement make no carrier decision.
+        def lower_routes(connector, priority)
+          @routes.select do |partner, _points, order|
+            !partner.equal?(connector) && order && order.size == priority.size &&
+              !same_source?(connector, partner) && (order <=> priority).negative?
+          end
+        end
+
+        def same_source?(connector, partner)
+          connector.source_element_ref && connector.source_element_ref == partner.source_element_ref
+        end
+
+        # Suppress both overlapping spans, including coincident crossings,
+        # so route order cannot select one of several ambiguous arcs.
+        def separate_crossings(crossings, axis)
+          crossings.reject.with_index do |point, index|
+            crossings.each_with_index.any? do |other, other_index|
+              index != other_index && (point[axis] - other[axis]).abs < 2 * RADIUS
+            end
+          end
+        end
+
+        def crossing(first, last, start, finish, axis)
+          return unless axis_for(start, finish) == 1 - axis
+
+          point = axis.zero? ? [start[0], first[1]] : [first[0], start[1]]
+          return unless segment_interior?(point, first, last, axis) &&
+                        segment_interior?(point, start, finish, 1 - axis)
+
+          point
+        end
+
+        def segment_interior?(point, first, last, axis)
+          interior?(point[axis], first[axis], last[axis])
+        end
+
+        def interior?(value, first, last)
+          minimum, maximum = [first, last].minmax
+          value > minimum && value < maximum &&
+            value - minimum >= RADIUS && maximum - value >= RADIUS
+        end
+
+        def axis_for(first, last)
+          return 0 if first[1] == last[1] && first[0] != last[0]
+          return 1 if first[0] == last[0] && first[1] != last[1]
+
+          nil
+        end
+
+        def arc_commands(first, last, crossing)
+          axis = axis_for(first, last)
+          direction = last[axis] > first[axis] ? 1 : -1
+          start = crossing.dup
+          finish = crossing.dup
+          start[axis] -= direction * RADIUS
+          finish[axis] += direction * RADIUS
+          ["L #{coordinates(start)}", "A #{RADIUS} #{RADIUS} 180 0 0 #{coordinates(finish)}"]
+        end
+
+        def coordinates(point)
+          point.map { |value| Canvas.coord(value) }.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/connector_redock.rb

@@ -16,9 +16,10 @@ module Ea
         # Returns replacement waypoint pairs for direct or lateral tree routes,
         # for the connector, or nil when the connector must keep its
         # parsed waypoints (not direct, not 2-point, unresolved ends,
-        # self-loop, or no drawn bounds for either end).
+        # self-loop, an authoritative UMLDI route, or no drawn bounds for either end).
         def pairs_for(connector, diagram, model_index, bounds_map)
           return nil unless bounds_map
+          return nil if connector.style.to_h[:umldi_route] == true
 
           tether = association_class_pairs(connector, bounds_map)
           return tether if tether
@@ -53,8 +54,8 @@ module Ea
 
           return nil if flush_lateral_line?(connector, points, source_bounds, target_bounds)
 
-          anchors = [connector.source_anchor, connector.target_anchor]
           bounds = [source_bounds, target_bounds]
+          anchors = drawn_center_anchors(connector, diagram, [source_ref, target_ref], bounds)
           original = clipped_pairs(bounds, anchors)
           unless stroke_outline?(connector, bounds) || overlap_ray?(connector) ||
                  bordered_outline?(connector, diagram, [source_ref, target_ref], bounds)
@@ -78,6 +79,38 @@ module Ea
           auto_port_elbow_pairs(connector, source, target, pairs)
         end
 
+        def drawn_center_anchors(connector, diagram, refs, bounds)
+          anchors = [connector.source_anchor, connector.target_anchor]
+          return anchors unless connector.style.to_h[:centered_origin_ray] == true
+
+          duids = connector.style.to_h.values_at(:soid, :eoid)
+          anchors.each_with_index.map do |anchor, index|
+            saved = unique_logical_bounds(diagram, refs[index], duids[index])
+            centered_anchor(anchor, saved, bounds[index])
+          end
+        end
+        private_class_method :drawn_center_anchors
+
+        def unique_logical_bounds(diagram, ref, duid)
+          placements = end_placements(diagram, ref, duid)
+          placements.first.bounds if placements.size == 1
+        end
+        private_class_method :unique_logical_bounds
+
+        def centered_anchor(anchor, saved, drawn)
+          return anchor unless anchor && saved
+
+          Ea::Model::Point.new(x: anchor.x + center_shift(saved, drawn, :x, :width),
+                               y: anchor.y + center_shift(saved, drawn, :y, :height))
+        end
+        private_class_method :centered_anchor
+
+        def center_shift(saved, drawn, coordinate, size)
+          drawn.public_send(coordinate) + drawn.public_send(size) / 2 -
+            saved.public_send(coordinate) - saved.public_send(size) / 2
+        end
+        private_class_method :center_shift
+
         # A tether joins its saved association anchor to the facing
         # side-center of the attached class, rather than to the other proxy.
         def association_class_pairs(connector, bounds_map)
@@ -475,6 +508,7 @@ module Ea
         def row_slot_adjust(pairs, connector, diagram, model_index,
                             bounds_map, divider_y_by_ref)
           return nil unless bounds_map && divider_y_by_ref
+          return nil if connector.style.to_h[:umldi_route] == true
           return nil unless pairs.size == 2
           return nil if flush_overlap_ray?(connector)
           return nil if explicit_association_ray?(pairs, connector)

data/lib/ea/svg/ea_emitter/connectors.rb

@@ -74,11 +74,14 @@ module Ea
         private
 
         def paths_with_styles
-          visible_connectors.filter_map do |connector|
-            path = path_for(connector)
-            next unless path
-
-            [[self.class.stroke_width_for(connector, stroke_width), dashed?(connector)], path]
+          routes = visible_connectors.filter_map do |connector|
+            points = resolved_points(connector)
+            [connector, points.map { |point| translate_point(point) }] if points.size >= 2
+          end
+          bridges = ConnectorBridges.new(diagram, routes)
+          routes.map do |connector, points|
+            [[self.class.stroke_width_for(connector, stroke_width), dashed?(connector)],
+             path_for(connector, points, bridges)]
           end
         end
 
@@ -103,39 +106,17 @@ module Ea
           (diagram.connectors || []).select(&:renderable?)
         end
 
-        def path_for(connector)
+        def resolved_points(connector)
           pts = ConnectorRedock.pairs_for(connector, diagram, model_index,
                                           drawn_bounds) ||
                 waypoints_for(connector)
-          pts = ConnectorRedock.row_slot_adjust(pts, connector, diagram,
-                                                model_index, drawn_bounds,
-                                                divider_y_by_ref) || pts
-          return nil if pts.size < 2
-
-          # DIRECT (auto-routed straight) connectors: EA writes the
-          # segment TARGET-FIRST with a trailing zero-length repeat —
-          # "M target L source M target" (B6847577, E58034A3,
-          # 8CF27BE8). Same pixels as source-first; only the byte
-          # order differs, so reversal lives here at the emitter and
-          # the marker anchoring (source = first waypoint) is
-          # untouched.
-          if pts.size == 2 && direct?(connector)
-            x1, y1 = translate_point(pts.first)
-            x2, y2 = translate_point(pts.last)
-            d = "M #{Canvas.coord(x2)} #{Canvas.coord(y2)} L #{Canvas.coord(x1)} #{Canvas.coord(y1)} " \
-                "M #{Canvas.coord(x2)} #{Canvas.coord(y2)}"
-          else
-            d = pts.each_with_index.map do |p, idx|
-              x, y = translate_point(p)
-              "#{idx.zero? ? 'M' : 'L'} #{Canvas.coord(x)} #{Canvas.coord(y)}"
-            end.join(" ")
-          end
-          %(<path d="#{d}" shape-rendering="auto"/>)
+          ConnectorRedock.row_slot_adjust(pts, connector, diagram,
+                                          model_index, drawn_bounds,
+                                          divider_y_by_ref) || pts
         end
 
-        def direct?(connector)
-          style = connector.style || {}
-          style.key?(:direct) || style.key?("direct")
+        def path_for(connector, pts, bridges)
+          %(<path d="#{bridges.path_for(connector, pts)}" shape-rendering="auto"/>)
         end
 
         def waypoints_for(connector)
@@ -146,10 +127,10 @@ module Ea
           end
         end
 
-        def translate_point(p)
-          return p unless @canvas
+        def translate_point(point)
+          return point unless @canvas
 
-          [@canvas.translate_x(p[0]), @canvas.translate_y(p[1])]
+          [@canvas.translate_x(point[0]), @canvas.translate_y(point[1])]
         end
       end
     end