ea 0.6.89 → 0.6.91

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbd238ad74b281cd5cb44ae2df2b49edd56eec8ab0001f8cf1694259a974c385
-  data.tar.gz: 978f6880bb2ffa3a9fd308047c62dd21e0869305ea832ac64b91de9f1c8303e9
+  metadata.gz: cf0f3e11888e4492386de976f97e4024e39d9dbc95083a5b184c0fb25d8cfead
+  data.tar.gz: 467687628f21bf50264c0210de75e2fad5013a14d7f2a1572d65dfb218429052
 SHA512:
-  metadata.gz: 44a797e58abb32b6434cb83eec2d84270a6499dc3c8d986a6da1a68da1074982a9217655d20e835bd5fe8812c8780a7a9775a9495d970cf0eb849694b0d6d9d3
-  data.tar.gz: 0c410271301a481b5085d7be62a2f45de58eb7fe46cad199e69e0f0f017f7648f4646305f2853ce248c5f6c62979f31c8d7087b7526945234315b8b6b6f63833
+  metadata.gz: 67a177d6e826985a3526c63bae7ed1f10e55b51ca97ec1507e5cb2f89f309b789f734c27cd41b678777e3ea72cb730a44485799972c3bbab916dedfd51f404c5
+  data.tar.gz: 55d5d873894f3e26fb786a71efaab326ecd4df2d16d167bf3dc7158e1775e139f9a9c2096cd79c5ae136315421c1d19156320d1c895837d691ecd7a97e772a2a

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
@@ -605,21 +609,15 @@ module Ea
           intermediate = intermediate_waypoints(link_row)
           if edge_out == 2 && source_port && target_port &&
              !valid_tree_path?(intermediate, source_placement)
-            # EA recomputes tree routes at DRAW TIME from current
-            # element positions when the stored Path no longer lands
-            # on the source's facing edge (hand-verified: SY 8542's
-            # stale Path vs EA-drawn route; CityObjectGroup's current
-            # Path renders byte-exact and is kept). Computed route:
-            # source port -> corner at (target dock x, source exit
-            # y) -> target port.
+            # A stale tree Path (not on the source's facing edge) is
+            # recomputed: source port -> corner at (target dock x,
+            # source exit y) -> target port.
             points = [[source_point[0], source_point[1]],
                       [target_point[0], source_point[1]],
                       [target_point[0], target_point[1]]]
           elsif edge_out == 2 && intermediate.size == 1
-            # Current tree Path (bend on the source's facing edge):
-            # EA's draw-time route shape — source right edge at the
-            # bend's y, corner at the bend, target facing edge at the
-            # bend's x (byte-exact on CityObjectGroup).
+            # Current tree Path: source right edge at the bend's y,
+            # corner at the bend, target facing edge at the bend's x.
             src = bounds_from_rect(source_placement)
             tgt = bounds_from_rect(target_placement)
             bend = intermediate.first
@@ -630,21 +628,11 @@ module Ea
                       [bend[0], target_y]]
           elsif intermediate.any?
             points = [source_point, *intermediate, target_point]
-            # Generalizations with the parent ABOVE keep their stored
-            # interior bends verbatim but re-dock the endpoints onto
-            # the box edges AT THE ADJACENT BEND's x (hand-verified:
-            # stored (542,975)(541,807)(543,807)(486,757) draws as
-            # (541,975)(541,807)(543,807)(543,757) — only the two
-            # endpoints move; the stale final x is replaced by the
-            # last bend's trunk x).
+            # Parent-above Generalizations keep stored interior bends
+            # and re-dock only the endpoints, at the adjacent bend's x.
             if connector.connector_type == "Generalization"
-              src_b = bounds_from_rect(source_placement)
-              tgt_b = bounds_from_rect(target_placement)
-              if tgt_b.y + tgt_b.height <= src_b.y
-                points[0] = [points[1][0].clamp(src_b.x, src_b.x + src_b.width), src_b.y]
-                points[-1] = [points[-2][0].clamp(tgt_b.x, tgt_b.x + tgt_b.width),
-                              tgt_b.y + tgt_b.height]
-              end
+              redock_parent_above(points, link_row, source_placement,
+                                  target_placement)
             end
           elsif source_port || target_port
             # Exact ports are known — the SX/SY bend heuristics in
@@ -654,20 +642,24 @@ module Ea
             points = sx_sy_ex_ey_waypoints(source_point, target_point, geom)
           end
 
-          # Associations/Aggregations between DISJOINT boxes: when the
-          # stored route does not already dock the closest FACING edge
-          # pair, EA redraws a straight aligned line between those
-          # edges (corpus: edge pair = min facing gap, 85% accurate;
-          # dock coordinate = the stored route's own coordinate
-          # clamped into the edges' overlap; simulation on 417
-          # identity-paired connectors: exact routes 41 -> 100).
-          # Tree-style (EDGE=2) connectors are excluded — their
-          # computed routes are already byte-exact.
+          # Between DISJOINT boxes, a stored route that does not dock the
+          # closest facing edge pair is redrawn straight between them.
+          # 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" &&
+               intermediate.any? && points.size >= 4 &&
+               generalization_outline_offset(link_row, points.size) == 1
+              redock_parent_above(points, link_row, source_placement,
+                                  target_placement, strict: true)
+            end
           end
 
           points.map do |x, y|
@@ -675,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
@@ -978,6 +908,35 @@ module Ea
 
           IdNormalizer.from_guid(conn.ea_guid)
         end
+
+        # Docks both ends of a bent route on the box edges at the
+        # adjacent bend's x when the target is above the source; interior
+        # bends stay. strict: skip an end whose bend is not beyond its dock.
+        def redock_parent_above(points, link_row, source_placement,
+                                target_placement, strict: false)
+          src_b = bounds_from_rect(source_placement)
+          tgt_b = bounds_from_rect(target_placement)
+          return points unless tgt_b.y + tgt_b.height <= src_b.y
+
+          inset = generalization_outline_offset(link_row, points.size)
+          source_y = src_b.y
+          target_y = tgt_b.y + tgt_b.height
+          source_y -= inset if points[1][1] < source_y - inset
+          target_y += inset if points[-2][1] > target_y + inset
+          unless strict && points[1][1] >= source_y
+            points[0] = [points[1][0].clamp(src_b.x, src_b.x + src_b.width), source_y]
+          end
+          unless strict && points[-2][1] <= target_y
+            points[-1] = [points[-2][0].clamp(tgt_b.x, tgt_b.x + tgt_b.width), target_y]
+          end
+          points
+        end
+
+        def generalization_outline_offset(link_row, point_count)
+          return 0 if point_count < 4
+
+          DiagramStyleParser.parse(link_row.style)[:lwidth] == "2" ? 1 : 0
+        end
       end
     end
   end

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

@@ -36,16 +36,45 @@ module Ea
           return nil unless source_bounds && target_bounds
           return nil if source_ref == target_ref
 
-          sa = connector.source_anchor
-          ta = connector.target_anchor
-          if sa && ta
-            [anchor_exit(sa, source_bounds, ta),
-             anchor_exit(ta, target_bounds, sa)]
+          anchors = [connector.source_anchor, connector.target_anchor]
+          bounds = [source_bounds, target_bounds]
+          original = clipped_pairs(bounds, anchors)
+          return original unless stroke_outline?(connector, bounds)
+
+          # EA docks these markers on the outer edge of the 2px box stroke.
+          outline = bounds.map do |box|
+            Ea::Model::Bounds.new(x: box.x - 1, y: box.y - 1,
+                                  width: box.width + 2, height: box.height + 2)
+          end
+          candidate = clipped_pairs(outline, anchors)
+          forward_route?(original, candidate) ? candidate : original
+        end
+
+        def stroke_outline?(connector, bounds)
+          connector.style.to_h[:lwidth] == "2" &&
+            %w[Generalization Aggregation].include?(connector.connector_type) &&
+            bounds.all? { |box| box.width.positive? && box.height.positive? }
+        end
+        private_class_method :stroke_outline?
+
+        def clipped_pairs(bounds, anchors)
+          source, target = bounds
+          source_anchor, target_anchor = anchors
+          if source_anchor && target_anchor
+            [anchor_exit(source_anchor, source, target_anchor),
+             anchor_exit(target_anchor, target, source_anchor)]
           else
-            [edge_point(source_bounds, target_bounds),
-             edge_point(target_bounds, source_bounds)]
+            [edge_point(source, target), edge_point(target, source)]
           end
         end
+        private_class_method :clipped_pairs
+
+        def forward_route?(original, candidate)
+          before = original.first.zip(original.last).map { |start, finish| finish - start }
+          after = candidate.first.zip(candidate.last).map { |start, finish| finish - start }
+          before.zip(after).sum { |old, current| old * current }.positive?
+        end
+        private_class_method :forward_route?
 
         # Exit point of the anchor-to-anchor segment through a box's
         # outline: smallest positive t whose crossing lies on the
@@ -101,21 +130,29 @@ module Ea
                       divider_y_by_ref[target_ref]]
           return nil unless bounds.all? && dividers.all?
 
-          changed = false
-          adjusted = pairs.each_with_index.map do |(x, y), i|
-            box = bounds[i]
-            divider = dividers[i]
-            at_edge = (x - box.x).abs <= 1 || (x - (box.x + box.width)).abs <= 1
-            at_divider = (y - divider.to_f).abs <= 1
-            if at_edge && at_divider
-              changed = true
-              [x, y + ROW_SLOT_PITCH]
-            else
-              [x, y]
-            end
+          adjusted = row_slot_pairs(pairs, bounds, dividers)
+          if stroke_outline?(connector, bounds) &&
+             pairs == pairs_for(connector, diagram, model_index, bounds_map)
+            original = clipped_pairs(bounds, [connector.source_anchor, connector.target_anchor])
+            original_final = row_slot_pairs(original, bounds, dividers)
+            adjusted = original_final if original != pairs && !forward_route?(original_final, adjusted)
+          end
+          adjusted == pairs ? nil : adjusted
+        end
+
+        def row_slot_pairs(pairs, bounds, dividers)
+          pairs.each_with_index.map do |(x, y), index|
+            row_slot?(x, y, bounds[index], dividers[index]) ? [x, y + ROW_SLOT_PITCH] : [x, y]
           end
-          changed ? adjusted : nil
         end
+        private_class_method :row_slot_pairs
+
+        def row_slot?(x_position, y_position, bounds, divider)
+          at_edge = (x_position - bounds.x).abs <= 1 ||
+                    (x_position - (bounds.x + bounds.width)).abs <= 1
+          at_edge && (y_position - divider.to_f).abs <= 1
+        end
+        private_class_method :row_slot?
 
         def direct?(connector)
           style = connector.style || {}

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

@@ -75,7 +75,7 @@ module Ea
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
 
             build_texts(role:, mult:, standalone:,
-                        text_pos:, mult_pos:, stereo:)
+                        text_pos:, mult_pos:, stereo:, text_box:)
           end
 
           private
@@ -110,12 +110,13 @@ module Ea
           end
 
           def build_texts(role:, mult:, standalone:, text_pos:, mult_pos:,
-                          stereo:)
+                          stereo:, text_box:)
             if role && !role.empty? && text_pos
               x, y = text_pos
               texts = [text_at(x, y, role)]
               if stereo
-                texts << text_at(x, y + property_y_offset, stereo)
+                stereo_x = x + stereotype_offset(role, stereo, text_box)
+                texts << text_at(stereo_x, y + property_y_offset, stereo)
               end
               if mult && !mult.empty? && mult_pos
                 texts << text_at(*mult_pos, mult)
@@ -128,6 +129,16 @@ module Ea
             end
           end
 
+          def stereotype_offset(role, stereo, text_box)
+            return 0 unless text_box && text_box["alignment"] == 1
+
+            role_width = TextRenderer.estimate_width(role, font_size,
+                                                     family: font_family).round
+            stereo_width = TextRenderer.estimate_width(stereo, font_size,
+                                                       family: font_family).round
+            ((role_width - stereo_width) / 2.0).round
+          end
+
           # EA renders «Property» between role name and multiplicity
           # exactly on connector ends carrying
           # t_connector.SourceStereotype / DestStereotype = "Property"

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

@@ -32,7 +32,7 @@ module Ea
             content = midpoint_content(connector)
             return nil if content.nil?
 
-            mx, my = midpoint(points)
+            mx, my = label_position(connector, points)
             # EA splits a "name: value" label at the colon-space into
             # two lines centered on the same slot (81F92FC7: "new
             # ownership:" / "LA_Right" at y 172/185, both centered on
@@ -95,6 +95,35 @@ module Ea
 
           LINE_PITCH = 13
 
+          def label_position(connector, points)
+            return midpoint(points) unless default_substitutable_seat?(connector) &&
+                                           upward_four_point_route?(points)
+
+            source, bend = points
+            [source[0] + 3, ((source[1] + bend[1]) / 2).floor - 1]
+          end
+
+          def default_substitutable_seat?(connector)
+            connector.is_a?(Ea::Model::DiagramConnector) && connector.is_substitutable &&
+              connector.connector_type == "Generalization" && font_size == 7 &&
+              stereotype_label(connector).nil? &&
+              default_constraint_box?(connector.label_boxes.to_h[:lmb])
+          end
+
+          def default_constraint_box?(box)
+            box && !box["hidden"] &&
+              box.values_at("ox", "oy", "rotation", "alignment") == [0, 0, 0, 0]
+          end
+
+          def upward_four_point_route?(points)
+            return false unless points.size == 4
+
+            source, first_bend, last_bend, target = points
+            source[0] == first_bend[0] && first_bend[1] == last_bend[1] &&
+              last_bend[0] == target[0] && source[1] > first_bend[1] &&
+              target[1] < last_bend[1]
+          end
+
           def midpoint(points)
             mid_idx = points.size / 2
             if points.size.odd?

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.89"
+  VERSION = "0.6.91"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.89
+  version: 0.6.91
 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