ea 0.6.27 → 0.6.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87b351667d7dc67e44be0352d005c0c06355be968b18dcf359ce7a3cf6a68e4f
-  data.tar.gz: 3a0f0868f7d7365ae17e3325fae1de7298d2683e61e7a8ca4be1febd4e6126bc
+  metadata.gz: 521d4fdcc042ad06bd18a829f39810ccef7df8f750bbe229c6d7c38ea3e45c2e
+  data.tar.gz: 49f8e753ae47eda15409252023e894e66949e590c579c9da7fb4140acc74e550
 SHA512:
-  metadata.gz: 6a8eb52cd341a1363ab9436b5c5ec3ba628a0f15c575ca108f3aea4e0d67d496f68ecbb3c2ea6406a96c0023f448bb408bd7616164fa372e9363c3567c685993
-  data.tar.gz: e685e2e88013ff81821438148b9fa5d3b38037200466903ec4771fa718b62c838c43a488b8ffffd58f1aec1f497781d67d6f84a2292224f76e4a2ac05f1aeb05
+  metadata.gz: 151b418a45c19c998c41957ddb471127f6e110689372a01e046152024c271b10ccb069af527c877ee6404cfe22c0323f55232e9140ba5a4882b382534a26b4b6
+  data.tar.gz: d2b597bfebed6432a78285f8898d73ef6cfdbbf65362132eed375b387bdc0aa1cfb40ceddabea22695060b8467e70c94768618b7a102bca556f0ab5351882955

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

@@ -432,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/svg/ea_emitter/marker/open_triangle.rb

@@ -5,8 +5,13 @@ module Ea
     module EaEmitter
       module Marker
         # Open triangle marker for UML generalization, realization,
-        # and dependency. White-filled 3-point polygon at the
-        # general / supplier end.
+        # and dependency. Generalization/Realization render a
+        # white-filled 3-point polygon at the general / supplier end;
+        # DEPENDENCY renders a line-style open path triangle (same
+        # style group as the connector line) — corpus-verified on
+        # E58034A3 where 22 directed dependencies converging on one
+        # package each draw a 'M a b L c d L a e' path triangle while
+        # the diagram's generalizations use polygons.
         class OpenTriangle < Kind
           def self.handles?(effective_type)
             %w[Generalization Realization Dependency].include?(effective_type)
@@ -16,7 +21,12 @@ module Ea
             whole_end_at_source = whole_end_at_source?(connector)
             anchor = whole_end_at_source ? target : source
             base = whole_end_at_source ? before_target : after_source
-            [Registry::Spec.new(shape: :triangle, anchor: anchor, base: base)]
+            shape = effective_type?(connector) == "Dependency" ? :arrow : :triangle
+            [Registry::Spec.new(shape: shape, anchor: anchor, base: base)]
+          end
+
+          def self.effective_type?(connector)
+            connector.connector_type
           end
         end
       end

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.27"
+  VERSION = "0.6.29"
 end

metadata

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