ea 0.6.26 → 0.6.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 523062f8a2bc8628a3c5b35aa5a074057307e4405b1d87ebf4150e471e592e29
-  data.tar.gz: 5ea75aecf1ed9a73b9a387e424073e1e7cc83e0161d9a2ab4db2c270136eea33
+  metadata.gz: c16a0778688fad772b4373999864fc0cd86d6b3d53cec3561ae14a97ad2457c8
+  data.tar.gz: 81408c1e187f5eda70ad9ed46f1f7904cc5931ca5152b43ea6385df5445f77b6
 SHA512:
-  metadata.gz: f1e366645ba375c9fd3701e97d7da847753bfa2719d52887f9df5b563f352b8b7d0172b3396967ff38529473f49f91d289dc8ea12937defc4ad3dba72f5ac4e7
-  data.tar.gz: 5389a63e4b5833ae5361e1d058059ecd4346f34de7e4965d4801dba2fc586ed43477729b81fc2a0e0897150d3853a82dbcd5d01f5b8f9caaf6a345e47159a034
+  metadata.gz: 1d2902fa0c76cf946a8751d01f3466295785c3326820e7a1e7fa029433e137a21046786caaf47f983e7edc4f8d5fd248004c25264eb3487fac67cbe79a36490e
+  data.tar.gz: 6972a73efe7333fa0cfc3af841f323d34d5c2077daa5572fdaa0976d650554b62a66c2f14ee24add12e750c5ded179c9ed6258798b15f16f19c2b8c7d00e92d9

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

@@ -408,6 +408,22 @@ 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).
+            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
+            end
           elsif source_port || target_port
             # Exact ports are known — the SX/SY bend heuristics in
             # sx_sy_ex_ey_waypoints would double-apply the offsets.
@@ -416,11 +432,89 @@ 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.
+          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))
+          end
+
           points.map do |x, y|
             Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
           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.26"
+  VERSION = "0.6.28"
 end

metadata

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