ea 0.6.90 → 0.6.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e78b8830cfb779be7d7724d11c984d11de76c2220aaae41502515f156e03aeca
-  data.tar.gz: d694be35c46f90866280700653aa35af66da37e9e3ec9bcf0724805b947550b0
+  metadata.gz: 641441bf5b181aaadd045223f47a59069d916f48247f19ab4e6bc6c19cfeee03
+  data.tar.gz: 0eb407d782f28301f0747a2f251ce3412f97cc60882f87cc7062567d1e7e4a64
 SHA512:
-  metadata.gz: 86c6dc4296a5c63c074178cdb01f19b171403e895b02dfb6e9897da9db87288a143228a3a0d7631953ddcf19ce2199a3060440fbd7472c472507af952206496c
-  data.tar.gz: f0a27398ba13e4b352ccda7e3f810485577f5e2ac5154f2a4b43ab276ae6c2778877318f5c0c58e9ce92caa95ce2e27d10b11e829785cf61bb916fc1ac7bbccc
+  metadata.gz: d705861a5209c8646e01fb097b4329e634744bdeef07355d00598a45bff1134ab186c69c0088250a3a3c5ece15d2c39281653c0e667a473fea80dbfd4bb9b9c0
+  data.tar.gz: 84fce6fa28c77169812dda317ef720035c1ac9b17ac854238aa376480980308b7c506e6f3fa52e23807e7cc851546fe65b0c6b8bda72b937b1d9a99ab82953ad

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      class DiagramBuilder
+        # Internal geometry for choosing the facing edges of stored routes.
+        module Routing
+          private
+
+          # 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
+
+            style = DiagramStyleParser.parse(link_row.style)
+            return false unless style[:tree] == "V" && style[:lwidth] == "2"
+
+            tree_bends_fit?(points[1], points[-2], src, tgt)
+          end
+
+          def tree_bends_fit?(first, last, source, target)
+            first[0] != last[0] && first[1] == last[1] &&
+              within_vertical_gap?(first[1], source, target) &&
+              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
+          end
+
+          def within_horizontal_span?(point, bounds)
+            point[0].between?(bounds.x, bounds.x + bounds.width)
+          end
+
+          # Returns a replacement 2-point route between the closest
+          # facing edges, or the original points when: the boxes overlap
+          # on both axes, the current route already docks those edges,
+          # or no aligned dock fits the edges' overlap range.
+          def facing_edge_route(points, src, tgt)
+            v_gap = v_dir = h_gap = h_dir = nil
+            if src.y >= tgt.y + tgt.height
+              v_gap = src.y - (tgt.y + tgt.height)
+              v_dir = [:t, :b]
+            elsif tgt.y >= src.y + src.height
+              v_gap = tgt.y - (src.y + src.height)
+              v_dir = [:b, :t]
+            end
+            if src.x >= tgt.x + tgt.width
+              h_gap = src.x - (tgt.x + tgt.width)
+              h_dir = [:l, :r]
+            elsif tgt.x >= src.x + src.width
+              h_gap = tgt.x - (tgt.x + tgt.width)
+              h_dir = [:r, :l]
+            end
+            return points if v_gap.nil? && h_gap.nil?
+
+            if !v_gap.nil? && (h_gap.nil? || v_gap <= h_gap)
+              src_edge, tgt_edge = v_dir
+            else
+              src_edge, tgt_edge = h_dir
+            end
+            return points if docks_edges?(points, src, src_edge, tgt, tgt_edge)
+
+            if %i[t b].include?(src_edge)
+              lo = [src.x, tgt.x].max
+              hi = [src.x + src.width, tgt.x + tgt.width].min
+              return points if lo > hi
+
+              x = points.first[0].clamp(lo, hi)
+              [[x, src_edge == :t ? src.y : src.y + src.height],
+               [x, tgt_edge == :t ? tgt.y : tgt.y + tgt.height]]
+            else
+              lo = [src.y, tgt.y].max
+              hi = [src.y + src.height, tgt.y + tgt.height].min
+              return points if lo > hi
+
+              y = points.first[1].clamp(lo, hi)
+              [[src_edge == :l ? src.x : src.x + src.width, y],
+               [tgt_edge == :l ? tgt.x : tgt.x + tgt.width, y]]
+            end
+          end
+
+          def docks_edges?(points, src, src_edge, tgt, tgt_edge)
+            on_edge?(points.first, src, src_edge) && on_edge?(points.last, tgt, tgt_edge)
+          end
+
+          def on_edge?(pt, b, edge, tol = 2)
+            x, y = pt
+            case edge
+            when :l then (x - b.x).abs <= tol && y.between?(b.y - tol, b.y + b.height + tol)
+            when :r then (x - (b.x + b.width)).abs <= tol && y.between?(b.y - tol, b.y + b.height + tol)
+            when :t then (y - b.y).abs <= tol && x.between?(b.x - tol, b.x + b.width + tol)
+            else (y - (b.y + b.height)).abs <= tol && x.between?(b.x - tol, b.x + b.width + tol)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,10 @@ module Ea
       # DiagramConnectors (including pixel coordinates and parsed
       # styles).
       class DiagramBuilder
+        autoload :Routing, "ea/sources/qea/diagram_builder/routing"
+        include Routing
+        private_constant :Routing
+
         attr_reader :database
 
         # Generalizations whose EA CustomProperties carry
@@ -643,9 +647,11 @@ module Ea
           # EDGE=2 routes are excluded; they are already exact.
           if %w[Association Aggregation].include?(connector.connector_type) &&
              edge_out != 2
-            points = facing_edge_route(points,
-                                       bounds_from_rect(source_placement),
-                                       bounds_from_rect(target_placement))
+            src = bounds_from_rect(source_placement)
+            tgt = bounds_from_rect(target_placement)
+            unless preserve_stored_tree?(points, link_row, connector, src, tgt)
+              points = facing_edge_route(points, src, tgt)
+            end
             # A width-2 Aggregation that keeps its stored bends is
             # docked like a Generalization one.
             if connector.connector_type == "Aggregation" &&
@@ -661,68 +667,6 @@ module Ea
           end
         end
 
-        # Returns a replacement 2-point route between the closest
-        # facing edges, or the original points when: the boxes overlap
-        # on both axes, the current route already docks those edges,
-        # or no aligned dock fits the edges' overlap range.
-        def facing_edge_route(points, src, tgt)
-          v_gap = v_dir = h_gap = h_dir = nil
-          if src.y >= tgt.y + tgt.height
-            v_gap = src.y - (tgt.y + tgt.height)
-            v_dir = [:t, :b]
-          elsif tgt.y >= src.y + src.height
-            v_gap = tgt.y - (src.y + src.height)
-            v_dir = [:b, :t]
-          end
-          if src.x >= tgt.x + tgt.width
-            h_gap = src.x - (tgt.x + tgt.width)
-            h_dir = [:l, :r]
-          elsif tgt.x >= src.x + src.width
-            h_gap = tgt.x - (tgt.x + tgt.width)
-            h_dir = [:r, :l]
-          end
-          return points if v_gap.nil? && h_gap.nil?
-
-          if !v_gap.nil? && (h_gap.nil? || v_gap <= h_gap)
-            src_edge, tgt_edge = v_dir
-          else
-            src_edge, tgt_edge = h_dir
-          end
-          return points if docks_edges?(points, src, src_edge, tgt, tgt_edge)
-
-          if %i[t b].include?(src_edge)
-            lo = [src.x, tgt.x].max
-            hi = [src.x + src.width, tgt.x + tgt.width].min
-            return points if lo > hi
-
-            x = points.first[0].clamp(lo, hi)
-            [[x, src_edge == :t ? src.y : src.y + src.height],
-             [x, tgt_edge == :t ? tgt.y : tgt.y + tgt.height]]
-          else
-            lo = [src.y, tgt.y].max
-            hi = [src.y + src.height, tgt.y + tgt.height].min
-            return points if lo > hi
-
-            y = points.first[1].clamp(lo, hi)
-            [[src_edge == :l ? src.x : src.x + src.width, y],
-             [tgt_edge == :l ? tgt.x : tgt.x + tgt.width, y]]
-          end
-        end
-
-        def docks_edges?(points, src, src_edge, tgt, tgt_edge)
-          on_edge?(points.first, src, src_edge) && on_edge?(points.last, tgt, tgt_edge)
-        end
-
-        def on_edge?(pt, b, edge, tol = 2)
-          x, y = pt
-          case edge
-          when :l then (x - b.x).abs <= tol && y.between?(b.y - tol, b.y + b.height + tol)
-          when :r then (x - (b.x + b.width)).abs <= tol && y.between?(b.y - tol, b.y + b.height + tol)
-          when :t then (y - b.y).abs <= tol && x.between?(b.x - tol, b.x + b.width + tol)
-          else (y - (b.y + b.height)).abs <= tol && x.between?(b.x - tol, b.x + b.width + tol)
-          end
-        end
-
         # A tree Path is current when its bend height still falls
         # within the source element's y-range (the exit height EA
         # records); a bend outside the element is stale and EA

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

@@ -19,6 +19,8 @@ module Ea
         # for those — only simple role names render.
         class EndLabel
           PROPERTY_STEREOTYPE = "«Property»"
+          SEAT_FONT_SIZE = 7
+          SEAT_X_INSET = 3
 
           attr_reader :canvas, :model_index, :document, :theme,
                       :font_family, :font_size, :font_unit
@@ -41,8 +43,9 @@ module Ea
           #   anchor     - [x, y] of the connector endpoint
           #   connector  - the DiagramConnector (for relationship lookup)
           #   end_kind   - :source or :target
+          #   heading    - [dx, dy] of the first leg leaving the anchor
           def texts(text_box:, mult_box:, anchor:, connector:, end_kind:,
-                    tree: false)
+                    tree: false, heading: nil)
             from_property, role, mult = role_and_multiplicity(connector, end_kind)
             if role_empty?(role) && mult_empty?(mult)
               other_from_prop, other_role, other_mult = role_and_multiplicity(connector,
@@ -73,6 +76,11 @@ module Ea
             # the end has none.
             stereo = connector_source_dest_stereotype(connector, end_kind)
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
+            direction = leg_direction(end_kind, heading)
+            if direction && !(tree && zero_offset?(text_box, mult_box))
+              text_pos = role_seat(direction, anchor, text_box, role) || text_pos
+              mult_pos = mult_seat(direction, anchor, mult_box) || mult_pos
+            end
 
             build_texts(role:, mult:, standalone:,
                         text_pos:, mult_pos:, stereo:, text_box:)
@@ -109,6 +117,63 @@ module Ea
             end
           end
 
+          # Stored source-end boxes on a 7pt label whose first leg
+          # leaves straight up or straight right are seated at the box
+          # corner, anchor + (OX, OY) with no sign flip, 3px to its
+          # right: the multiplicity 6px above it on an upward leg and
+          # 15px below it on a rightward one, the role 7px above it on
+          # a rightward one. Other sizes, headings, the target end,
+          # custom presentation keep their offsets; zero multiplicity boxes keep their default seat.
+          def leg_direction(end_kind, heading)
+            return nil unless source_seat?(end_kind, heading)
+
+            dx, dy = heading
+            return :up if dx.zero? && dy.negative?
+            return :right if dy.zero? && dx.positive?
+
+            nil
+          end
+
+          # Role text on a rightward leg is left-aligned at the corner,
+          # 7px above it. Upward legs keep the plain role offset.
+          def role_seat(direction, anchor, box, role)
+            return nil unless direction == :right
+            return nil if box.nil? || role_empty?(role)
+            return nil unless default_presentation?(box)
+
+            x, y = seat_corner(anchor, box)
+            [x + SEAT_X_INSET, y - 7]
+          end
+
+          def mult_seat(direction, anchor, box)
+            return nil if box.nil? || stored_offsets_zero?(box)
+            return nil unless default_presentation?(box)
+
+            x, y = seat_corner(anchor, box)
+            [x + SEAT_X_INSET, direction == :right ? y + 15 : y - 6]
+          end
+
+          def source_seat?(end_kind, heading)
+            end_kind == :source && heading &&
+              font_size == SEAT_FONT_SIZE && font_unit == "pt"
+          end
+
+          # Boxes with explicit string-keyed OX/OY (the QEA shape) that
+          # are unrotated, unhidden, unstyled and left/center aligned.
+          def default_presentation?(box)
+            return false unless box["ox"] && box["oy"]
+            return false unless [nil, 0, 1].include?(box["alignment"])
+            return false unless [nil, -1].include?(box["color"])
+
+            box["rotation"].to_i.zero? && box["direction"].to_i.zero? &&
+              box.values_at("hidden", "bold", "italic", "underline")
+                 .none?
+          end
+
+          def seat_corner(anchor, box)
+            [anchor[0] + box["ox"].to_i, anchor[1] + box["oy"].to_i]
+          end
+
           def build_texts(role:, mult:, standalone:, text_pos:, mult_pos:,
                           stereo:, text_box:)
             if role && !role.empty? && text_pos

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

@@ -78,15 +78,16 @@ module Ea
           boxes = connector.label_boxes || {}
           tree = tree_shaped?(points)
 
-          src_tb, src_mb = end_boxes(boxes, :llt, :llb) ||
-                           default_label_boxes(points, :source)
+          stored_src = end_boxes(boxes, :llt, :llb)
+          src_tb, src_mb = stored_src || default_label_boxes(points, :source)
           tgt_tb, tgt_mb = end_boxes(boxes, :lrt, :lrb) ||
                            default_label_boxes(points, :target)
 
           texts = []
           end_renderer.texts(text_box: src_tb, mult_box: src_mb,
                              anchor: source_pt, connector: connector,
-                             end_kind: :source, tree: tree && tree[:source]).each { |t| texts << t }
+                             end_kind: :source, tree: tree && tree[:source],
+                             heading: stored_src && leg_heading(points)).each { |t| texts << t }
           end_renderer.texts(text_box: tgt_tb,
                              mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
@@ -105,6 +106,10 @@ module Ea
           { source: true, target: true }
         end
 
+        def leg_heading(points)
+          [points[1][0] - points[0][0], points[1][1] - points[0][1]]
+        end
+
         def end_boxes(boxes, text_key, mult_key)
           return nil if boxes[text_key].nil? && boxes[mult_key].nil?
 

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.90"
+  VERSION = "0.6.92"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.90
+  version: 0.6.92
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -815,6 +815,7 @@ files:
 - lib/ea/sources/qea/connector_relationship_map.rb
 - lib/ea/sources/qea/context_diagram_support.rb
 - lib/ea/sources/qea/diagram_builder.rb
+- lib/ea/sources/qea/diagram_builder/routing.rb
 - lib/ea/sources/qea/diagram_style_parser.rb
 - lib/ea/sources/qea/id_normalizer.rb
 - lib/ea/sources/qea/instance_builder.rb