ea 0.6.90 → 0.6.91

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e78b8830cfb779be7d7724d11c984d11de76c2220aaae41502515f156e03aeca
-  data.tar.gz: d694be35c46f90866280700653aa35af66da37e9e3ec9bcf0724805b947550b0
+  metadata.gz: cf0f3e11888e4492386de976f97e4024e39d9dbc95083a5b184c0fb25d8cfead
+  data.tar.gz: 467687628f21bf50264c0210de75e2fad5013a14d7f2a1572d65dfb218429052
 SHA512:
-  metadata.gz: 86c6dc4296a5c63c074178cdb01f19b171403e895b02dfb6e9897da9db87288a143228a3a0d7631953ddcf19ce2199a3060440fbd7472c472507af952206496c
-  data.tar.gz: f0a27398ba13e4b352ccda7e3f810485577f5e2ac5154f2a4b43ab276ae6c2778877318f5c0c58e9ce92caa95ce2e27d10b11e829785cf61bb916fc1ac7bbccc
+  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
@@ -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/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.91"
 end

metadata

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