ea 0.6.98 → 0.6.100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3c13e631927ad57c6168b6d7c02eaed8e933c89ad7dfcd0a055fb6b8a69e8e1
-  data.tar.gz: 3edb35912780be1170fce402dd141823f4c5e44c92a6f84451fa136d3eb026a8
+  metadata.gz: 8f60cf58bb521e911eb26fb30b628162e149a9521027fae0e77756ef1b8354dd
+  data.tar.gz: c0580ced4122e41650fbc5053fb0fb534a40c8cae84f758039dd8b2f575422ad
 SHA512:
-  metadata.gz: 6544102e41ff1bde04737e18f93de5ea0ee657c47335f7eeb12316162ca33fbf2e0d5b0dc1572fccc5174373781b1368508d606641286c88ebe2d7f9f2232079
-  data.tar.gz: eb3cb4702ea44ba8759ab9774a1ca445684b9d6ce7043153b4823657c191fff45c6db267ee74b1ed20cdec2064248b60a0f5112827b92edfa4aaecaa495fa093
+  metadata.gz: 6460bd84357b97c350c485526bcc62bc74309d924eacd9e7983347b101c22d1fcfc246dc7b76d443eb04cb360e2be890eaf1cffedf49103e9f2419b5205fe3a7
+  data.tar.gz: 2a8ce3556ffa2b5531e432002ab7a67439cd4f4ed171c1f84f141b264e9fa6913af3ffd8983dbb0be70c9282407fdb3695efb07728c0217c656688ed38f8d023

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

@@ -23,6 +23,56 @@ module Ea
             set_stored_ray_origins(model, source, target, geom)
           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.
+          # The stored jog is stale; the ray docks on both 1px outlines.
+          def mode2_overlap_ray(model, link_row, diagram_row, geom, context)
+            return model if context || !mode2_overlap_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            column = overlap_ray_coordinate(source.x, source.width, target.x, target.width, geom[:sx])
+            return model unless column && vertical_separation?(source, target)
+
+            set_overlap_ray(model, column, source, target)
+          end
+
+          def set_overlap_ray(model, column, source, target)
+            model.waypoints = overlap_ray_ends(column, source, target).map do |x, y|
+              Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+            end
+            model.source_anchor, model.target_anchor = [source, target].map do |box|
+              Ea::Model::Point.new(x: column, y: box.y + box.height / 2)
+            end
+            model
+          end
+
+          def mode2_overlap_candidate?(model, link_row, geom)
+            model.connector_type == "Generalization" && model.has_geometry_offsets &&
+              mode2_overlap_style?(model.style.to_h, geom) && model.waypoints.size == 4 &&
+              horizontal_jog?(intermediate_waypoints(link_row))
+          end
+
+          def mode2_overlap_style?(style, geom)
+            style[:mode] == "2" && style[:lwidth] == "2" && !style[:tree] && geom[:edge] == 1 && geom[:sx]
+          end
+
+          def horizontal_jog?(corners)
+            corners.size == 2 && corners[0][1] == corners[1][1]
+          end
+
+          def vertical_separation?(source, target)
+            source.y + source.height < target.y || target.y + target.height < source.y
+          end
+
+          def overlap_ray_ends(column, source, target)
+            if target.y + target.height < source.y
+              [[column, source.y - 1], [column, target.y + target.height + 1]]
+            else
+              [[column, source.y + source.height + 1], [column, target.y - 1]]
+            end
+          end
+
           def empty_path_ray_gap?(source, target, geom)
             return false unless source.x + source.width < target.x
 
@@ -55,6 +105,134 @@ module Ea
             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.
+          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)
+            return model unless origins
+
+            model.waypoints = [model.source_port, model.target_port].map do |point|
+              Ea::Model::Waypoint.new(position: point)
+            end
+            model.source_anchor, model.target_anchor = origins
+            model
+          end
+
+          def association_ray_origins(source, target, geom)
+            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])
+          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)
+          end
+
+          def association_ray_style?(style)
+            style[:mode] == "3" && !style[:tree] && %w[0 2].include?(style[:lwidth]) &&
+              %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
+          # 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) }
+          end
+
+          def on_border?(point, bounds)
+            [bounds.x, bounds.x + bounds.width].include?(point.x) ||
+              [bounds.y, bounds.y + bounds.height].include?(point.y)
+          end
+
+          def inside_box?(point, bounds)
+            point.x.between?(bounds.x, bounds.x + bounds.width) &&
+              point.y.between?(bounds.y, bounds.y + bounds.height)
+          end
+
+          # A Mode 2 Association with equal SX/EX (vertical EDGE 1/3) or
+          # equal SY/EY (horizontal EDGE 4) and no custom Path docks as a
+          # straight line through the middle of the boxes' overlap, moved
+          # by the shared stored offset. Stored SY counts upward.
+          def overlap_ray_origins(model, link_row, diagram_row, geom, context)
+            return model if context
+            return model unless overlap_ray_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            origins = overlap_origins(source, target, geom)
+            return model unless origins
+
+            model.source_anchor, model.target_anchor = origins.map do |ox, oy|
+              Ea::Model::Point.new(x: ox, y: oy)
+            end
+            model.style[:overlap_ray] = true
+            model
+          end
+
+          # Both ray origins share the overlap coordinate on the axis the
+          # offsets move and sit at each box's centre on the other axis.
+          def overlap_origins(source, target, geom)
+            along, across, offset = overlap_axes(geom)
+            coordinate = overlap_ray_coordinate(*box_span(source, along), *box_span(target, along), offset)
+            return nil unless coordinate && disjoint_span?(*box_span(source, across), *box_span(target, across))
+
+            [source, target].map do |box|
+              start, size = box_span(box, across)
+              centre = start + size / 2.0
+              geom[:edge] == 4 ? [centre, coordinate] : [coordinate, centre]
+            end
+          end
+
+          # [axis the offsets move, axis the boxes face, stored offset]
+          def overlap_axes(geom)
+            return [%i[y height], %i[x width], -geom[:sy]] if geom[:edge] == 4
+
+            [%i[x width], %i[y height], geom[:sx]]
+          end
+
+          def box_span(box, keys)
+            keys.map { |key| box.public_send(key) }
+          end
+
+          def overlap_ray_candidate?(model, link_row, geom)
+            model.connector_type == "Association" && model.style[:mode] == "2" &&
+              model.waypoints.size == 2 && link_row.path.to_s.empty? &&
+              model.has_geometry_offsets && uniform_overlap_offsets?(geom)
+          end
+
+          def uniform_overlap_offsets?(geom)
+            return false unless geom.values_at(:sx, :sy, :ex, :ey).all?
+
+            geom[:edge] == 4 ? geom[:sy] == geom[:ey] : [1, 3].include?(geom[:edge]) && geom[:sx] == geom[:ex]
+          end
+
+          # Floor of the overlap midpoint plus the shared offset; nil
+          # when the boxes do not overlap on this axis.
+          def overlap_ray_coordinate(start_a, size_a, start_b, size_b, offset)
+            low = [start_a, start_b].max
+            high = [start_a + size_a, start_b + size_b].min
+            return nil if low > high
+
+            coordinate = ((low + high) / 2.0 + offset).floor
+            coordinate if coordinate.between?(low, high)
+          end
+
+          def disjoint_span?(start_a, size_a, start_b, size_b)
+            start_a + size_a < start_b || start_b + size_b < start_a
+          end
+
           def stored_ray_boxes(link_row, diagram_row)
             connector = database.find_connector(link_row.connectorid)
             [source_placement_for(connector, diagram_row),
@@ -115,6 +293,85 @@ module Ea
                                  y: bounds.y + bounds.height / 2 - y_offset.to_i)
           end
 
+          # A vertical tree stores its trunk bend twice when the parent sits
+          # directly above; EA draws that as one bend.
+          def drop_zero_length_tree_segments(points, link_row)
+            return points unless points.size == 4 && points[1] == points[2] &&
+                                 DiagramStyleParser.parse(link_row.style)[:tree] == "V"
+
+            points.values_at(0, 1, 3)
+          end
+
+          # A stored vertical tree trunk docks both ends on the box edges that
+          # face its bends, at the adjacent bend's x: Aggregations without
+          # geometry offsets whose child sits below, and flush Associations
+          # whose parent sits above. Other shapes keep their stored docks.
+          def redock_vertical_tree_trunk(points, link_row, connector, source_placement, target_placement)
+            style = DiagramStyleParser.parse(link_row.style)
+            return unless points.size == 4 && style[:tree] == "V"
+
+            case connector.connector_type
+            when "Aggregation"
+              return unless style[:lwidth] == "0" || !geometry_has_offsets?(link_row.geometry)
+
+              redock_child_below(points, bounds_from_rect(source_placement), bounds_from_rect(target_placement))
+            when "Association"
+              return unless style[:lwidth] == "0"
+
+              redock_parent_above(points, link_row, source_placement, target_placement, strict: true)
+            end
+          end
+
+          def redock_child_below(points, src_b, tgt_b)
+            first_bend, last_bend = points.values_at(1, -2)
+            source_y = src_b.y + src_b.height
+            return points unless source_y <= tgt_b.y && first_bend[1] > source_y && last_bend[1] < tgt_b.y
+
+            points[0] = [clamp_to_span(first_bend[0], src_b), source_y]
+            points[-1] = [clamp_to_span(last_bend[0], tgt_b), tgt_b.y]
+            points
+          end
+
+          def clamp_to_span(position, bounds)
+            position.clamp(bounds.x, bounds.x + bounds.width)
+          end
+
+          # A stored-Path Mode 3 width-2 end whose adjacent bend lies level
+          # with its box (inside the box's span on one axis, outside on the
+          # other) enters the box orthogonally on the outer outline at that
+          # bend's coordinate. Bends that are not level keep the port and
+          # every authored corner stays.
+          def level_entry_route(points, link_row, connector, src, tgt)
+            return points unless points.size >= 3 && level_entry_style?(link_row, connector)
+
+            route = points.dup
+            first = level_entry_point(route[1], src)
+            last = level_entry_point(route[-2], tgt)
+            route[0] = first if first
+            route[-1] = last if last
+            route
+          end
+
+          def level_entry_style?(link_row, connector)
+            style = DiagramStyleParser.parse(link_row.style)
+            %w[Generalization Aggregation].include?(connector.connector_type) &&
+              style[:mode] == "3" && style[:lwidth] == "2" && !style.key?(:tree)
+          end
+
+          def level_entry_point(bend, box)
+            level_y = bend[1] > box.y && bend[1] < box.y + box.height
+            level_x = bend[0] > box.x && bend[0] < box.x + box.width
+            if level_y && outside_span?(bend[0], box.x, box.width)
+              [bend[0] < box.x ? box.x - 1 : box.x + box.width + 1, bend[1]]
+            elsif level_x && outside_span?(bend[1], box.y, box.height)
+              [bend[0], bend[1] < box.y ? box.y - 1 : box.y + box.height + 1]
+            end
+          end
+
+          def outside_span?(value, start, length)
+            value < start || value > start + length
+          end
+
           # Square routing keeps the stored orthogonal trunk, even when a
           # shorter facing-edge route exists between the same boxes.
           def stored_square_route(link_row, connector, source, target)
@@ -164,19 +421,29 @@ module Ea
 
           # A valid lateral corner joins one vertical leg and one horizontal
           # leg. Keep it even when the boxes also admit a shorter direct route.
-          def stored_lateral_route(link_row, connector, source, target)
+          # ported: both ends carry explicit SX/SY and EX/EY offsets. An
+          # untyped corner without them may be an authored diagonal.
+          def stored_lateral_route(link_row, connector, source, target, ported: false)
             return nil unless %w[Aggregation Association].include?(connector.connector_type)
 
             style = DiagramStyleParser.parse(link_row.style)
-            return nil unless stored_lateral_style?(style)
+            return nil unless stored_lateral_style?(style, connector, ported)
 
             corner = stored_lateral_corner(link_row)
-            return nil unless corner
+            corner && lateral_corner_route(style, corner, source, target)
+          end
 
-            if style[:tree] == "LH"
-              horizontal_corner_route(corner, source, target)
+          # An untyped Mode 3 Association corner takes whichever leg
+          # orientation its position fits; width-2 docks sit on the 1px
+          # outer outline.
+          def lateral_corner_route(style, corner, source, target)
+            case style[:tree]
+            when "LH" then horizontal_corner_route(corner, source, target)
+            when "LV" then vertical_corner_route(corner, source, target)
             else
-              vertical_corner_route(corner, source, target)
+              outline = style[:lwidth] == "2" ? 1 : 0
+              horizontal_corner_route(corner, source, target, outline) ||
+                vertical_corner_route(corner, source, target, outline)
             end
           end
 
@@ -186,8 +453,11 @@ module Ea
             intermediate_waypoints(link_row).first
           end
 
-          def stored_lateral_style?(style)
-            style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) && %w[LH LV].include?(style[:tree])
+          def stored_lateral_style?(style, connector, ported)
+            return false unless style[:mode] == "3" && %w[0 2].include?(style[:lwidth])
+
+            %w[LH LV].include?(style[:tree]) ||
+              (style[:tree].nil? && ported && connector.connector_type == "Association")
           end
 
           def horizontal_corner?(corner, source, target)
@@ -195,13 +465,13 @@ module Ea
               !within_height?(corner[1], source) && !within_horizontal_span?(corner, target)
           end
 
-          def horizontal_corner_route(corner, source, target)
+          def horizontal_corner_route(corner, source, target, outline = 0)
             return nil unless horizontal_corner?(corner, source, target)
 
             x, y = corner
 
-            source_y = y < source.y ? source.y : source.y + source.height
-            target_x = x < target.x ? target.x : target.x + target.width
+            source_y = y < source.y ? source.y - outline : source.y + source.height + outline
+            target_x = x < target.x ? target.x - outline : target.x + target.width + outline
             [[x, source_y], corner, [target_x, y]]
           end
 
@@ -210,13 +480,13 @@ module Ea
               !within_horizontal_span?(corner, source) && !within_height?(corner[1], target)
           end
 
-          def vertical_corner_route(corner, source, target)
+          def vertical_corner_route(corner, source, target, outline = 0)
             return nil unless vertical_corner?(corner, source, target)
 
             x, y = corner
 
-            source_x = x < source.x ? source.x : source.x + source.width
-            target_y = y < target.y ? target.y : target.y + target.height
+            source_x = x < source.x ? source.x - outline : source.x + source.width + outline
+            target_y = y < target.y ? target.y - outline : target.y + target.height + outline
             [[source_x, y], corner, [x, target_y]]
           end
 
@@ -242,14 +512,13 @@ module Ea
           # Keep a vertical tree trunk whose bends still fit both boxes
           # and the open gap; the closest facing edges need not share its x.
           def preserve_stored_tree?(points, link_row, connector, src, tgt)
-            return false unless connector.connector_type == "Aggregation" && points.size == 4
+            return false unless points.size == 4 && stored_tree_type?(points, link_row, connector)
 
             style = DiagramStyleParser.parse(link_row.style)
             return false unless style[:lwidth] == "2" || flush_width_zero_tree?(link_row)
-            return false unless style[:tree] == "V" ||
-                                (style[:mode] == "3" && style[:tree].nil?)
+            return false unless vertical_tree_style?(style)
 
-            tree_bends_fit?(points[1], points[-2], src, tgt)
+            tree_bends_fit?(points[1], points[-2], src, tgt, flush_width_zero_tree?(link_row))
           end
 
           # A width-2 Mode 3 horizontal tree keeps its stored vertical trunk
@@ -320,6 +589,38 @@ module Ea
             model
           end
 
+          # Same one-pixel collapse for a two-waypoint computed line when only
+          # the target carries an explicit port (the source end is the default
+          # edge midpoint): the left-hand end's y wins.
+          def collapse_partial_port_jog(model, link_row, diagram_row)
+            return model unless partial_port_jog_candidate?(model, link_row)
+
+            connection = database.find_connector(link_row.connectorid)
+            src, tgt = [connection.start_object_id, connection.end_object_id].map do |id|
+              placement = diagram_object_placement(diagram_row.diagram_id, id)
+              placement && bounds_from_rect(placement)
+            end
+            from, to = model.waypoints.map(&:position)
+            return model unless src && tgt && facing_jog_ports?(from, to, src, tgt)
+
+            level = [from, to].min_by(&:x).y
+            ends = [[from.x, level], [to.x, level]].map do |x, y|
+              Ea::Model::Point.new(x: x, y: y)
+            end
+            model.waypoints = ends.map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.source_anchor = model.source_port = ends.first
+            model.target_anchor = model.target_port = ends.last
+            model
+          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
+          end
+
           def computed_jog_candidate?(model, link_row, geom)
             style = model.style.to_h
             model.connector_type == "Generalization" && geom[:edge] == 2 &&
@@ -346,14 +647,32 @@ module Ea
             style[:mode] == "3" && style[:tree] == "V" && style[:lwidth] == "0"
           end
 
-          def tree_bends_fit?(first, last, source, target)
-            first[0] != last[0] && first[1] == last[1] &&
-              within_vertical_gap?(first[1], source, target) &&
+          def vertical_tree_style?(style)
+            style[:tree] == "V" || (style[:mode] == "3" && style[:tree].nil?)
+          end
+
+          def stored_tree_type?(points, link_row, connector)
+            connector.connector_type == "Aggregation" || flush_straight_association?(points, link_row, connector)
+          end
+
+          # A flush Association keeps only a straight trunk (one bend stored twice).
+          def flush_straight_association?(points, link_row, connector)
+            connector.connector_type == "Association" && points[1] == points[-2] &&
+              flush_width_zero_tree?(link_row)
+          end
+
+          # A flush trunk may also hang below its parent; a bend repeated at
+          # one x is a straight trunk with a single bend.
+          def tree_bends_fit?(first, last, source, target, flush)
+            first[1] == last[1] &&
+              within_vertical_gap?(first[1], source, target, flush) &&
               within_horizontal_span?(first, source) && within_horizontal_span?(last, target)
           end
 
-          def within_vertical_gap?(height, source, target)
-            height < source.y - 1 && height > target.y + target.height + 1
+          def within_vertical_gap?(height, source, target, flush)
+            return true if height < source.y - 1 && height > target.y + target.height + 1
+
+            flush && height > source.y + source.height + 1 && height < target.y - 1
           end
 
           def within_horizontal_span?(point, bounds)

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

@@ -421,8 +421,12 @@ module Ea
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry),
             is_substitutable: substitutable_connector?(connector)
           ), link_row, diagram_row, geom)
+          model = collapse_partial_port_jog(model, link_row, diagram_row)
           model = direct_empty_path_ray(model, link_row, diagram_row, geom, context)
-          correct_stored_ray_origins(model, link_row, diagram_row, geom, 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)
         end
 
         # Ray origin for one connector end: the element's center
@@ -662,7 +666,8 @@ 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_lateral_route(link_row, connector, src, tgt) ||
+                       stored_lateral_route(link_row, connector, src, tgt,
+                                            ported: source_port && target_port) ||
                        horizontal_tree_route(points, link_row, connector, src, tgt)
           if tree_route
             points = tree_route
@@ -681,8 +686,15 @@ module Ea
               redock_parent_above(points, link_row, source_placement,
                                   target_placement, strict: true)
             end
+            if intermediate.any?
+              redock_vertical_tree_trunk(points, link_row, connector, source_placement, target_placement)
+            end
           end
 
+          if intermediate.any? && !tree_route
+            points = level_entry_route(points, link_row, connector, src, tgt)
+          end
+          points = drop_zero_length_tree_segments(points, link_row)
           points.map do |x, y|
             Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
           end

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

@@ -42,7 +42,7 @@ module Ea
           anchors = [connector.source_anchor, connector.target_anchor]
           bounds = [source_bounds, target_bounds]
           original = clipped_pairs(bounds, anchors)
-          return original unless stroke_outline?(connector, bounds)
+          return original unless stroke_outline?(connector, bounds) || overlap_ray?(connector)
 
           # EA docks these markers on the outer edge of the 2px box stroke.
           outline = bounds.map do |box|
@@ -103,6 +103,14 @@ module Ea
         end
         private_class_method :stroke_outline?
 
+        # The QEA builder marks the Mode 2 Association overlap rays it
+        # produced; EA docks them on the outer stroke edge whatever the
+        # line width. Naturally aligned centres keep the legacy docking.
+        def overlap_ray?(connector)
+          connector.connector_type == "Association" && connector.style.to_h[:overlap_ray] == true
+        end
+        private_class_method :overlap_ray?
+
         def outline_connector?(connector, bounds)
           return true if %w[Generalization Aggregation].include?(connector.connector_type)
 
@@ -197,6 +205,7 @@ module Ea
                             bounds_map, divider_y_by_ref)
           return nil unless bounds_map && divider_y_by_ref
           return nil unless pairs.size == 2
+          return nil if explicit_association_ray?(pairs, connector)
 
           rel = relationship_for(connector, model_index)
           return nil unless rel
@@ -231,16 +240,28 @@ module Ea
         end
         private_class_method :explicit_horizontal_source_dock?
 
-        def explicit_horizontal_ray?(connector)
-          explicit_horizontal_ray_style?(connector) && connector.has_geometry_offsets &&
+        # A stored Association ray whose source port certifies the shared
+        # 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)
+          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 :explicit_association_ray?
+
+        def explicit_horizontal_ray?(connector, types = %w[Generalization Aggregation])
+          explicit_horizontal_ray_style?(connector, types) && connector.has_geometry_offsets &&
             connector.source_port && connector.target_port &&
             connector.source_anchor && connector.target_anchor
         end
         private_class_method :explicit_horizontal_ray?
 
-        def explicit_horizontal_ray_style?(connector)
+        def explicit_horizontal_ray_style?(connector, types)
           style = connector.style.to_h
-          %w[Generalization Aggregation].include?(connector.connector_type) &&
+          types.include?(connector.connector_type) &&
             style[:mode] == "3" && !style[:tree] && !style[:direct] && !style[:regenerated]
         end
         private_class_method :explicit_horizontal_ray_style?

data/lib/ea/svg/ea_emitter/label/end_label.rb

@@ -22,6 +22,10 @@ module Ea
           SEAT_FONT_SIZE = 7
           SEAT_X_INSET = 3
           SEAT_STEREOTYPE_GAP = 12
+          # EA keeps an upward property seat's left edge at diagram x >= 3;
+          # the stereotype line moves with the role. Measured only for the
+          # default Cambria 7pt boxed cluster.
+          MIN_ROLE_X = 3
 
           attr_reader :canvas, :model_index, :document, :theme,
                       :font_family, :font_size, :font_unit
@@ -93,7 +97,8 @@ module Ea
               mult_pos = directional_multiplicity(connector, direction, anchor, mult_box, mult) ||
                          mult_seat(direction, anchor, mult_box) || mult_pos
             elsif end_kind == :target && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = target_upward_role(connector, heading, anchor, text_box, role) || text_pos
+              text_pos = target_vertical_role(connector, heading, anchor, text_box, role) ||
+                         target_rightward_role(heading, anchor, text_box, role) || text_pos
               mult_pos = target_multiplicity_seat(heading, anchor, mult_box) || mult_pos
             end
 
@@ -187,7 +192,9 @@ module Ea
 
             x, y = seat_corner(anchor, box)
             inset, baseline = property_role_offsets(direction)
-            [x - inset - width, y + baseline]
+            left = x - inset - width
+            left = [left, MIN_ROLE_X].max if direction == :up
+            [left, y + baseline]
           end
 
           def plain_upward_seat(connector, direction, anchor, box, role)
@@ -203,34 +210,59 @@ module Ea
             [x - SEAT_X_INSET - width, y - 6]
           end
 
-          def target_upward_role(connector, heading, anchor, box, role)
-            return nil unless heading && heading[0].zero? && heading[1].negative?
+          def target_vertical_role(connector, heading, anchor, box, role)
+            return nil unless heading && heading[0].zero? && !heading[1].zero?
+
+            direction = heading[1].negative? ? :target_up : :target_down
+            plain_vertical_role(connector, direction, anchor, box, role)
+          end
 
-            plain_vertical_role(connector, :target_up, anchor, box, role)
+          # A target whose leg arrives from the right seats its role like a
+          # source whose leg leaves to the right.
+          def target_rightward_role(heading, anchor, box, role)
+            return nil unless heading && heading[1].zero? && heading[0].positive?
+            return nil unless seat_font? && cambria_box?(box) && !role_empty?(role)
+
+            x, y = seat_corner(anchor, box)
+            [x + SEAT_X_INSET, y - 7]
           end
 
           def plain_vertical_role(connector, direction, anchor, box, role)
-            return nil unless %i[down target_up].include?(direction) && plain_vertical_box?(box)
+            return nil unless %i[down target_up target_down].include?(direction) &&
+                              plain_vertical_box?(box)
 
             end_kind = direction == :down ? :source : :target
-            return nil unless plain_vertical_connector?(connector, end_kind)
+            return nil unless plain_vertical_connector?(connector, end_kind, direction)
 
             width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
             return nil unless width
 
             x, y = seat_corner(anchor, box)
-            [x - width - 8, y + (end_kind == :source ? 15 : -7)]
+            [x - width - 8, y + (direction == :target_up ? -7 : 15)]
           end
 
           def plain_vertical_box?(box)
             seat_font? && cambria_box?(box) && [0, 1].include?(box["alignment"])
           end
 
-          def plain_vertical_connector?(connector, end_kind)
-            style = connector.style.to_h
-            connector.connector_type == "Association" &&
-              connector_source_dest_stereotype(connector, end_kind).empty? &&
-              style[:mode] == "3" && style[:lwidth] == "0" && !style[:tree]
+          # A target leg that runs down seats only on the "LV" tree route
+          # with line width 2; every other vertical seat needs the plain
+          # width-0 route.
+          def plain_vertical_connector?(connector, end_kind, direction)
+            return false unless connector.connector_type == "Association" &&
+                                connector_source_dest_stereotype(connector, end_kind).empty?
+
+            plain_vertical_style?(connector.style.to_h, direction)
+          end
+
+          def plain_vertical_style?(style, direction)
+            return false unless style[:mode] == "3"
+
+            if direction == :target_down
+              style[:lwidth] == "2" && style[:tree] == "LV"
+            else
+              style[:lwidth] == "0" && !style[:tree]
+            end
           end
 
           def plain_role_route?(style)
@@ -261,7 +293,7 @@ module Ea
             case direction
             when :left then left_property_route?(style)
             when :down then downward_property_route?(style)
-            else style[:lwidth] == "2" && style[:tree] != "OS"
+            else %w[0 2].include?(style[:lwidth]) && style[:tree] != "OS"
             end
           end
 

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

@@ -97,7 +97,7 @@ module Ea
                              mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
                              end_kind: :target, tree: tree && tree[:target],
-                             heading: stored_tgt && leg_heading(points.reverse),
+                             heading: stored_tgt && target_heading(connector, points),
                              stored_labels: stored_labels).each { |t| texts << t }
           texts
         end
@@ -126,6 +126,19 @@ module Ea
           stored_upward_heading(connector, heading)
         end
 
+        # A target dock that clips an axis-aligned stored leg into a slight
+        # diagonal keeps the stored leg's direction.
+        def target_heading(connector, points)
+          heading = leg_heading(points.reverse)
+          return heading unless points.size == 2 && heading.none?(&:zero?)
+
+          stored = waypoint_pairs(connector)
+          return heading unless stored.size == 2
+
+          original = leg_heading(stored.reverse)
+          original.any?(&:zero?) ? original : heading
+        end
+
         def stored_upward_heading(connector, heading)
           return heading unless heading[1].negative?
 

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.98"
+  VERSION = "0.6.100"
 end

metadata

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