ea 0.6.100 → 0.6.102

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f60cf58bb521e911eb26fb30b628162e149a9521027fae0e77756ef1b8354dd
-  data.tar.gz: c0580ced4122e41650fbc5053fb0fb534a40c8cae84f758039dd8b2f575422ad
+  metadata.gz: c453170a8a782786ce0a1061623c8de93ed75536228bb99d9b6c1857163f58f3
+  data.tar.gz: 19c5dc1e01e47508e51dfc87add4cd24059b4035b83ed45c5aa98d46d4edcb8b
 SHA512:
-  metadata.gz: 6460bd84357b97c350c485526bcc62bc74309d924eacd9e7983347b101c22d1fcfc246dc7b76d443eb04cb360e2be890eaf1cffedf49103e9f2419b5205fe3a7
-  data.tar.gz: 2a8ce3556ffa2b5531e432002ab7a67439cd4f4ed171c1f84f141b264e9fa6913af3ffd8983dbb0be70c9282407fdb3695efb07728c0217c656688ed38f8d023
+  metadata.gz: 26fbc91c4d39c834e0e9a19c443501953b487210ea88922be813bf167dfb56c6d2cc55cb3238441f58a08a6cd7511560e495f787a05a566466e9e7c5f45b06b0
+  data.tar.gz: 79f6d211068cf179e2fee6eea24e2e0ae60385be826db2254dcb6ce3d3aab345d68c743f529d430b242f8ea0cc3fdda7425e6cf880cf984abf1b7aeec145d74c

data/lib/ea/sources/qea/diagram_builder/routing.rb

@@ -23,6 +23,16 @@ module Ea
             set_stored_ray_origins(model, source, target, geom)
           end
 
+          def mark_default_square_ray(model, link_row, geom, context)
+            style = model.style.to_h
+            return model if context || !link_row.path.to_s.empty? || model.waypoints.size != 2
+            return model unless style[:mode] == "3" && style[:tree] == "OS" && style[:lwidth] == "2"
+            return model unless geom[:sx].nil? && geom[:sy].nil? && [geom[:ex], geom[:ey]] == [0, 0]
+
+            model.style = style.merge(default_square_ray: true)
+            model
+          end
+
           # A Mode 2 Generalization whose stored Path is a horizontal jog
           # between vertically separated boxes that overlap in x is EA's
           # auto-route: one vertical ray at the overlap midpoint plus SX.
@@ -100,40 +110,108 @@ module Ea
             return model unless stored_ray_candidate?(model, link_row, geom)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
-            return model unless stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
+            allowed = if normalized_port_anchors?(model)
+                        normalized_level_ray?(model, source, target, geom)
+                      else
+                        stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
+                      end
+            return model unless allowed
 
             set_stored_ray_origins(model, source, target, geom)
           end
 
-          # An empty-Path Mode 3 Association with explicit offsets on both
-          # ends is the straight line between the two stored ray origins.
-          # Origins outside their own box are not a stored ray.
+          # An empty-Path Mode 3 Association follows the line between its
+          # stored endpoint origins; an omitted offset defaults to the center.
+          # The target origin must lie inside its own stroked outline.
           def association_stored_ray(model, link_row, diagram_row, geom, context)
             return model if context
             return model unless association_ray_candidate?(model, link_row)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
-            origins = association_ray_origins(source, target, geom)
+            width = association_outline_width(model, link_row, diagram_row)
+            origins = association_ray_origins(source, target, geom, width)
             return model unless origins
 
-            model.waypoints = [model.source_port, model.target_port].map do |point|
-              Ea::Model::Waypoint.new(position: point)
-            end
+            model.waypoints = port_waypoints(model, origins)
             model.source_anchor, model.target_anchor = origins
+            model.style = model.style.to_h.merge(stored_association_ray: true, association_ray_outline: true)
+            if geom[:edge] == 1 && !inside_box?(origins.first, grown_bounds(source, width == "2" ? 1 : 0))
+              model.style[:stored_top_dock] = true
+            end
             model
           end
 
-          def association_ray_origins(source, target, geom)
+          def port_waypoints(model, origins)
+            [model.source_port || origins.first, model.target_port || origins.last].map do |point|
+              Ea::Model::Waypoint.new(position: point)
+            end
+          end
+
+          # Width-2 boxes also own their 1px outer stroke, so a stored
+          # origin on that outline is still inside its box.
+          def association_ray_origins(source, target, geom, width)
+            outline = width == "2" ? 1 : 0
             origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
                        stored_ray_origin(target, geom[:ex], geom[:ey])]
-            inside = origins.zip([source, target]).all? { |o, b| inside_box?(o, b) }
-            origins if inside && sub_pixel_safe_origins?(origins, [source, target])
+            boxes = [source, target].map { |box| grown_bounds(box, outline) }
+            return unless origins.first != origins.last && association_origin_pair?(origins, boxes, width, geom[:edge])
+
+            origins if width == "2" || sub_pixel_safe_origins?(origins, [source, target] + boxes)
+          end
+
+          # An external source origin is a virtual point on the saved ray.
+          # It is usable only when that segment actually crosses the source.
+          def association_origin_pair?(origins, boxes, width, edge)
+            return false unless inside_box?(origins.last, boxes.last)
+            return true if inside_box?(origins.first, boxes.first)
+
+            return segment_crosses_box?(origins.first, origins.last, boxes.first) if width == "2"
+            return false unless edge == 1
+
+            source = boxes.first
+            top = Ea::Model::Bounds.new(x: source.x, y: source.y, width: source.width, height: 0)
+            segment_crosses_box?(origins.first, origins.last, top)
+          end
+
+          def segment_crosses_box?(first, last, box)
+            interval = [0.0, 1.0]
+            axes = [[first.x, last.x, box.x, box.x + box.width],
+                    [first.y, last.y, box.y, box.y + box.height]]
+            axes.all? do |origin, finish, low, high|
+              if origin == finish
+                origin.between?(low, high)
+              else
+                times = [(low - origin).to_f / (finish - origin),
+                         (high - origin).to_f / (finish - origin)].minmax
+                interval = [[interval.first, times.first].max, [interval.last, times.last].min]
+                interval.first <= interval.last
+              end
+            end
+          end
+
+          def grown_bounds(bounds, amount)
+            Ea::Model::Bounds.new(x: bounds.x - amount, y: bounds.y - amount,
+                                  width: bounds.width + 2 * amount,
+                                  height: bounds.height + 2 * amount)
           end
 
           def association_ray_candidate?(model, link_row)
             model.connector_type == "Association" && link_row.path.to_s.empty? &&
-              model.has_geometry_offsets && model.source_port && model.target_port &&
-              association_ray_style?(model.style.to_h)
+              model.source_anchor && model.target_anchor &&
+              (model.source_port || model.target_port) && association_ray_style?(model.style.to_h)
+          end
+
+          # A thin connector still meets the outer stroke of explicitly
+          # bordered elements. Ambiguous placements must agree on that border.
+          def association_outline_width(model, link_row, diagram_row)
+            width = model.style[:lwidth]
+            return width if width == "2"
+
+            connector = database.find_connector(link_row.connectorid)
+            ids = [connector.start_object_id, connector.end_object_id]
+            placements = database.diagram_objects_for(diagram_row.diagram_id)
+            borders = placements.select { |placement| ids.include?(placement.ea_object_id) }
+            borders.all? { |placement| DiagramStyleParser.parse(placement.objectstyle)[:lwth] == "2" } ? "2" : width
           end
 
           def association_ray_style?(style)
@@ -141,15 +219,13 @@ module Ea
               %i[direct regenerated].none? { |key| style.key?(key) }
           end
 
-          # Origins are whole pixels while EA's box centers may sit on a
-          # half pixel. An origin on its border then clips differently
+          # Width-0 origins are whole pixels while EA's box centers may sit
+          # on a half pixel. An origin on its border then clips differently
           # unless the line is axis-aligned, which no rounding changes.
           def sub_pixel_safe_origins?(origins, boxes)
             first, last = origins
-            return false if first == last
-
             axis_aligned = first.x == last.x || first.y == last.y
-            axis_aligned || origins.zip(boxes).none? { |point, box| on_border?(point, box) }
+            axis_aligned || origins.none? { |point| boxes.any? { |box| on_border?(point, box) } }
           end
 
           def on_border?(point, bounds)
@@ -248,7 +324,21 @@ module Ea
           def stored_ray_candidate?(model, link_row, geom)
             %w[Generalization Aggregation].include?(model.connector_type) &&
               model.waypoints.size == 2 && stored_ray_style?(model.style, link_row) &&
-              stored_ray_geometry?(model, geom) && !normalized_port_anchors?(model)
+              stored_ray_geometry?(model, geom)
+          end
+
+          # Boundary-port rounding can move a computed jog off a level saved
+          # ray. Equal stored origin rows specify the line before clipping.
+          def normalized_level_ray?(model, source, target, geom)
+            style = model.style.to_h
+            return false unless style[:mode] == "3" && style[:lwidth] == "2" &&
+                                horizontal_ray_gap?(source, target)
+
+            origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
+                       stored_ray_origin(target, geom[:ex], geom[:ey])]
+            boxes = [source, target].map { |box| grown_bounds(box, 1) }
+            origins.first.y == origins.last.y &&
+              origins.zip(boxes).all? { |origin, box| inside_box?(origin, box) }
           end
 
           def stored_ray_style?(style, link_row)
@@ -352,6 +442,14 @@ module Ea
             route
           end
 
+          # One stored corner that is level with both boxes already is the
+          # route (vertical leg out of the source, horizontal leg into the
+          # target); flattening it to the facing edges would lose it.
+          def level_corner_route?(points, link_row, connector, src, tgt)
+            points.size == 3 && level_entry_style?(link_row, connector) &&
+              !level_entry_point(points[1], src).nil? && !level_entry_point(points[1], tgt).nil?
+          end
+
           def level_entry_style?(link_row, connector)
             style = DiagramStyleParser.parse(link_row.style)
             %w[Generalization Aggregation].include?(connector.connector_type) &&
@@ -419,6 +517,62 @@ module Ea
               [bounds.y, bounds.y + bounds.height].include?(point[1])
           end
 
+          # A width-2 Mode 3 Aggregation without a tree style keeps an authored
+          # orthogonal stair-step of three or more corners. Each end docks on
+          # the 1px outline its adjacent leg points at, from the corner's own
+          # coordinate; any end that cannot do so leaves the route unchanged.
+          def stored_stair_route(link_row, connector, source, target)
+            return nil unless stair_style?(link_row, connector)
+
+            corners = stored_square_corners(link_row)
+            return nil unless corners && corners.size >= 3 && alternating_legs?(corners)
+
+            first = outline_dock(corners[0], corners[1], source)
+            last = outline_dock(corners[-1], corners[-2], target)
+            [first, *corners, last] if first && last
+          end
+
+          def stair_style?(link_row, connector)
+            style = DiagramStyleParser.parse(link_row.style)
+            connector.connector_type == "Aggregation" && style[:mode] == "3" &&
+              style[:lwidth] == "2" && !style.key?(:tree)
+          end
+
+          # Every leg is non-zero and runs along the opposite axis of the last.
+          def alternating_legs?(corners)
+            axes = corners.each_cons(2).map { |from, to| leg_axis(from, to) }
+            axes.none?(&:nil?) && axes.each_cons(2).all? { |a, b| a != b }
+          end
+
+          def leg_axis(from, to)
+            return :vertical if from[0] == to[0] && from[1] != to[1]
+
+            :horizontal if from[1] == to[1] && from[0] != to[0]
+          end
+
+          # The dock runs perpendicular to the corner's own leg.
+          def outline_dock(corner, neighbour, box)
+            if corner[1] == neighbour[1]
+              vertical_outline_dock(corner, box)
+            else
+              horizontal_outline_dock(corner, box)
+            end
+          end
+
+          def vertical_outline_dock(corner, box)
+            x, y = corner
+            return nil unless x.between?(box.x, box.x + box.width) && !within_height?(y, box)
+
+            [x, y < box.y ? box.y - 1 : box.y + box.height + 1]
+          end
+
+          def horizontal_outline_dock(corner, box)
+            x, y = corner
+            return nil unless within_height?(y, box) && !x.between?(box.x, box.x + box.width)
+
+            [x < box.x ? box.x - 1 : box.x + box.width + 1, y]
+          end
+
           # A valid lateral corner joins one vertical leg and one horizontal
           # leg. Keep it even when the boxes also admit a shorter direct route.
           # ported: both ends carry explicit SX/SY and EX/EY offsets. An
@@ -433,6 +587,66 @@ module Ea
             corner && lateral_corner_route(style, corner, source, target)
           end
 
+          # A horizontal lateral tree with no usable stored corner leaves
+          # the source's top or bottom edge at its center x, turns at the
+          # target's center y and enters the target's facing side edge.
+          # When that y lies inside the source's height the route is one
+          # horizontal line between the facing side edges. Every dock is
+          # flush on its box edge.
+          def derived_lateral_route(link_row, connector, source, target)
+            style = DiagramStyleParser.parse(link_row.style)
+            return nil unless style[:mode] == "3" && style[:tree] == "LH" &&
+                              derived_lateral_path?(connector.connector_type, link_row.path.to_s)
+
+            x = source.x + source.width / 2
+            y = target.y + target.height / 2
+            edge = lateral_target_edge(x, target)
+            return nil unless edge
+
+            if within_height?(y, source)
+              side = target.x > x ? source.x + source.width : source.x
+              [[side, y], [edge, y]] if ((edge - side) * (edge - x)).positive?
+            else
+              [[x, y < source.y ? source.y : source.y + source.height], [x, y], [edge, y]]
+            end
+          end
+
+          # An Association may carry one stored corner that no valid lateral
+          # route accepted; a Generalization derives only from an empty Path.
+          def derived_lateral_path?(connector_type, path)
+            case connector_type
+            when "Association" then path.match?(/\A(?:-?\d+:-?\d+;?)?\z/)
+            when "Generalization" then path.empty?
+            else false
+            end
+          end
+
+          # A derived level line docks flush at its own two ends; anchoring
+          # the ray there keeps the emitter's clip from moving them.
+          def pin_derived_lateral_line(model, link_row, diagram_row, context)
+            style = model.style.to_h
+            return model if context || model.waypoints.size != 2 ||
+                            style[:mode] != "3" || style[:tree] != "LH"
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            connector = database.find_connector(link_row.connectorid)
+            line = connector && derived_lateral_route(link_row, connector, source, target)
+            return model unless line && line.size == 2 &&
+                                line == model.waypoints.map { |wp| [wp.position.x, wp.position.y] }
+
+            model.source_anchor, model.target_anchor = line.map { |x, y| Ea::Model::Point.new(x: x, y: y) }
+            model.style = style.merge(derived_lateral_line: true)
+            model
+          end
+
+          # The target side edge a vertical leg at x faces, or nil when x
+          # lies within the target's span.
+          def lateral_target_edge(x_position, target)
+            return target.x if x_position < target.x
+
+            target.x + target.width if x_position > target.x + target.width
+          end
+
           # An untyped Mode 3 Association corner takes whichever leg
           # orientation its position fits; width-2 docks sit on the 1px
           # outer outline.
@@ -613,12 +827,44 @@ module Ea
             model
           end
 
+          # A two-waypoint Mode 3 Aggregation with only a target port draws the
+          # line from the source center to the target's stored ray origin
+          # (center + EX, center - EY), clipped at the outlines; the boundary
+          # port is only the derived crossing of that origin's ray.
+          def correct_partial_port_origins(model, link_row, diagram_row, geom, context)
+            return model if context || !partial_port_origin_candidate?(model, link_row)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            return model unless horizontal_ray_gap?(source, target)
+
+            model.source_anchor = stored_ray_origin(source, 0, 0)
+            model.target_anchor = stored_ray_origin(target, geom[:ex], geom[:ey])
+            model
+          end
+
+          def partial_port_origin_candidate?(model, link_row)
+            style = model.style.to_h
+            model.connector_type == "Aggregation" && model.waypoints.size == 2 &&
+              link_row.path.to_s.empty? && style[:mode] == "3" && style[:lwidth] == "2" &&
+              !style.key?(:tree) &&
+              model.source_port.nil? && model.target_port
+          end
+
           def partial_port_jog_candidate?(model, link_row)
             style = model.style.to_h
             model.connector_type == "Aggregation" &&
-              link_row.path.to_s.empty? && style[:mode] == "3" && style[:lwidth] == "2" &&
-              !style.key?(:tree) && model.source_port.nil? && model.target_port &&
-              model.waypoints.size == 2
+              link_row.path.to_s.empty? && style[:mode] == "3" &&
+              !style.key?(:tree) && model.waypoints.size == 2 &&
+              explicit_port_side?(model, style[:lwidth])
+          end
+
+          # Width 2 keeps the evidenced target-only port; width 0 accepts a
+          # single explicit port at either end.
+          def explicit_port_side?(model, width)
+            ports = [model.source_port, model.target_port]
+            return model.source_port.nil? && !model.target_port.nil? if width == "2"
+
+            width == "0" && ports.compact.size == 1
           end
 
           def computed_jog_candidate?(model, link_row, geom)

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

@@ -362,12 +362,20 @@ module Ea
             target_stereotype: conn.deststereotype,
             waypoints: waypoints,
             label_boxes: DEFAULT_LABEL_BOXES,
-            style: PHANTOM_DOUBLE_BACK_TYPES.include?(conn.connector_type) ? { direct: true } : {},
+            style: phantom_style(conn.connector_type),
             hidden: false,
             has_geometry_offsets: false
           )
         end
 
+        # Internal producer flag, like :direct. A model relationship with no
+        # link row is stroked at the 2px box outline, so its ends dock there.
+        def phantom_style(connector_type)
+          return { direct: true } if PHANTOM_DOUBLE_BACK_TYPES.include?(connector_type)
+
+          %w[Aggregation Association].include?(connector_type) ? { phantom_outline: true } : {}
+        end
+
         # Computes the edge attachment point on source bounds that
         # faces the target bounds. Uses the center-to-center direction
         # to pick the nearest edge intersection.
@@ -422,11 +430,14 @@ module Ea
             is_substitutable: substitutable_connector?(connector)
           ), link_row, diagram_row, geom)
           model = collapse_partial_port_jog(model, link_row, diagram_row)
+          model = correct_partial_port_origins(model, link_row, diagram_row, geom, context)
           model = direct_empty_path_ray(model, link_row, diagram_row, geom, context)
+          model = pin_derived_lateral_line(model, link_row, diagram_row, context)
           model = mode2_overlap_ray(model, link_row, diagram_row, geom, context)
           model = association_stored_ray(model, link_row, diagram_row, geom, context)
           model = correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
-          overlap_ray_origins(model, link_row, diagram_row, geom, context)
+          model = overlap_ray_origins(model, link_row, diagram_row, geom, context)
+          mark_default_square_ray(model, link_row, geom, context)
         end
 
         # Ray origin for one connector end: the element's center
@@ -666,15 +677,17 @@ module Ea
           src = bounds_from_rect(source_placement)
           tgt = bounds_from_rect(target_placement)
           tree_route = stored_square_route(link_row, connector, src, tgt) ||
+                       stored_stair_route(link_row, connector, src, tgt) ||
                        stored_lateral_route(link_row, connector, src, tgt,
                                             ported: source_port && target_port) ||
+                       derived_lateral_route(link_row, connector, src, tgt) ||
                        horizontal_tree_route(points, link_row, connector, src, tgt)
           if tree_route
             points = tree_route
           elsif %w[Association Aggregation].include?(connector.connector_type) &&
                 edge_out != 2
             stored_tree = preserve_stored_tree?(points, link_row, connector, src, tgt)
-            unless stored_tree
+            unless stored_tree || level_corner_route?(points, link_row, connector, src, tgt)
               points = facing_edge_route(points, src, tgt)
             end
             # A width-2 Aggregation that keeps its stored bends is

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

@@ -39,10 +39,16 @@ module Ea
             return target && [points[0], points[1], target]
           end
 
+          return nil if flush_lateral_line?(connector, points, source_bounds, target_bounds)
+
           anchors = [connector.source_anchor, connector.target_anchor]
           bounds = [source_bounds, target_bounds]
           original = clipped_pairs(bounds, anchors)
-          return original unless stroke_outline?(connector, bounds) || overlap_ray?(connector)
+          unless stroke_outline?(connector, bounds) || overlap_ray?(connector) ||
+                 bordered_outline?(connector, diagram, [source_ref, target_ref], bounds)
+            pairs = default_square_pairs(connector, points, source_bounds, target_bounds, original)
+            return stored_top_pairs(connector, source_bounds, pairs)
+          end
 
           # EA docks these markers on the outer edge of the 2px box stroke.
           outline = bounds.map do |box|
@@ -50,8 +56,70 @@ module Ea
                                   width: box.width + 2, height: box.height + 2)
           end
           candidate = clipped_pairs(outline, anchors)
-          forward_route?(original, candidate) ? candidate : original
+          expanded = forward_route?(original, candidate)
+          pairs = expanded ? candidate : original
+          target = expanded ? outline.last : target_bounds
+          pairs = default_square_pairs(connector, points, source_bounds, target, pairs)
+          stored_top_pairs(connector, expanded ? outline.first : source_bounds, pairs)
+        end
+
+        # EDGE=1 explicitly seats an external source ray on the top edge;
+        # its first contact can instead be the bottom when its origin is below.
+        def stored_top_pairs(connector, source, pairs)
+          return pairs unless connector.connector_type == "Association" &&
+                              connector.style.to_h[:stored_top_dock] == true
+
+          first = connector.source_anchor
+          last = connector.target_anchor
+          return pairs unless first && last && first.y != last.y
+
+          ratio = (source.y - first.y).to_f / (last.y - first.y)
+          x_position = first.x + ratio * (last.x - first.x)
+          return pairs unless ratio.between?(0, 1) &&
+                              x_position.between?(source.x, source.x + source.width)
+
+          proposed = [[x_position.floor, source.y], pairs.last]
+          forward_route?(pairs, proposed) ? proposed : pairs
+        end
+        private_class_method :stored_top_pairs
+
+        # A square ray with an omitted source offset keeps its chosen side
+        # edge and projects that end to the clipped target's horizontal row.
+        def default_square_pairs(connector, points, source, target, pairs)
+          return pairs unless connector.style.to_h[:default_square_ray] == true
+          return pairs unless points.first[1] == points.last[1] &&
+                              on_side_edge?(points.first, source) && on_side_edge?(pairs.last, target)
+
+          first = [points.first[0], pairs.last[1]]
+          return pairs unless on_side_edge?(first, source)
+
+          proposed = [first, pairs.last]
+          forward_route?(points, proposed) ? proposed : pairs
+        end
+        private_class_method :default_square_pairs
+
+        # A horizontal lateral tree the QEA builder derived as one level
+        # line (internal style flag) keeps it between the facing side edges.
+        def flush_lateral_line?(connector, points, source, target)
+          style = connector.style.to_h
+          return false unless style[:derived_lateral_line] && style[:mode] == "3" &&
+                              style[:tree] == "LH" && points.size == 2 &&
+                              %w[Association Generalization].include?(connector.connector_type)
+          return false unless connector.source_anchor && connector.target_anchor
+
+          first, last = points
+          pinned = [[connector.source_anchor.x, connector.source_anchor.y],
+                    [connector.target_anchor.x, connector.target_anchor.y]]
+          pinned == [first, last] && first[1] == last[1] &&
+            on_side_edge?(first, source) && on_side_edge?(last, target)
         end
+        private_class_method :flush_lateral_line?
+
+        def on_side_edge?(point, bounds)
+          [bounds.x, bounds.x + bounds.width].include?(point[0]) &&
+            point[1].between?(bounds.y, bounds.y + bounds.height)
+        end
+        private_class_method :on_side_edge?
 
         def lateral_tree?(connector, points)
           style = connector.style.to_h
@@ -97,7 +165,7 @@ module Ea
         private_class_method :facing_coordinate
 
         def stroke_outline?(connector, bounds)
-          connector.style.to_h[:lwidth] == "2" &&
+          (connector.style.to_h[:lwidth] == "2" || default_model_connector?(connector)) &&
             bounds.all? { |box| box.width.positive? && box.height.positive? } &&
             outline_connector?(connector, bounds)
         end
@@ -111,9 +179,42 @@ module Ea
         end
         private_class_method :overlap_ray?
 
+        # The QEA builder flags a model relationship drawn without any
+        # diagram link row; EA strokes it at the 2px box outline.
+        def default_model_connector?(connector)
+          connector.style.to_h[:phantom_outline] == true && !connector.has_geometry_offsets &&
+            %w[Aggregation Association].include?(connector.connector_type)
+        end
+        private_class_method :default_model_connector?
+
+        # A thin straight Generalization/Aggregation/Association between two elements
+        # drawn with a 2px border stops on the outer edge of those borders.
+        def bordered_outline?(connector, diagram, refs, bounds)
+          style = connector.style.to_h
+          return false unless style[:lwidth] == "0" && !style[:tree]
+          return false unless %w[Generalization Aggregation Association].include?(connector.connector_type)
+          return false unless bounds.all? { |box| box.width.positive? && box.height.positive? }
+
+          ends = [[refs.first, style[:soid]], [refs.last, style[:eoid]]]
+          ends.all? { |ref, duid| border_two?(diagram, ref, duid) }
+        end
+        private_class_method :bordered_outline?
+
+        # Every placement of the element (the DUID-matched one when the
+        # connector names it) must declare a border width of 2.
+        def border_two?(diagram, ref, duid)
+          placed = Array(diagram&.elements).select { |el| el.model_element_ref == ref }
+          named = placed.select { |el| duid && el.duid.to_s.casecmp?(duid.to_s) }
+          placed = named unless named.empty?
+          placed.any? && placed.all? { |el| el.line_width == 2 || el.style.to_h[:lwth] == "2" }
+        end
+        private_class_method :border_two?
+
         def outline_connector?(connector, bounds)
+          return true if default_model_connector?(connector)
           return true if %w[Generalization Aggregation].include?(connector.connector_type)
 
+          return true if association_ray_outline?(connector)
           return false unless stored_association?(connector) || offset_free_association?(connector)
 
           # Diagonal Association rounding and tree docks keep their existing rules.
@@ -122,6 +223,15 @@ module Ea
         end
         private_class_method :outline_connector?
 
+        # The QEA builder marks the stored Association rays it produced;
+        # their diagonal docks sit on the outer stroke edge like the
+        # axis-aligned ones. Unmarked diagonals keep the legacy docking.
+        def association_ray_outline?(connector)
+          connector.connector_type == "Association" &&
+            connector.style.to_h[:association_ray_outline] == true
+        end
+        private_class_method :association_ray_outline?
+
         def stored_association?(connector)
           style = connector.style.to_h
           connector.connector_type == "Association" && connector.has_geometry_offsets &&
@@ -244,12 +354,20 @@ module Ea
         # anchor row is one explicit horizontal line: EA seats neither end
         # in a compartment row, unlike Generalization/Aggregation targets.
         def explicit_association_ray?(pairs, connector)
+          produced = connector.style.to_h[:stored_association_ray] == true
+          return true if produced && pairs.first[1] == pairs.last[1]
+
+          certified_association_ray?(pairs, connector)
+        end
+
+        def certified_association_ray?(pairs, connector)
           return false unless explicit_horizontal_ray?(connector, %w[Association])
 
           connector.source_anchor.y == connector.target_anchor.y &&
             connector.source_port.y == connector.source_anchor.y &&
             pairs.first[1] == pairs.last[1]
         end
+        private_class_method :certified_association_ray?
         private_class_method :explicit_association_ray?
 
         def explicit_horizontal_ray?(connector, types = %w[Generalization Aggregation])

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.100"
+  VERSION = "0.6.102"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.100
+  version: 0.6.102
 platform: ruby
 authors:
 - Ribose Inc.