ea 0.6.89 → 0.6.90

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbd238ad74b281cd5cb44ae2df2b49edd56eec8ab0001f8cf1694259a974c385
-  data.tar.gz: 978f6880bb2ffa3a9fd308047c62dd21e0869305ea832ac64b91de9f1c8303e9
+  metadata.gz: e78b8830cfb779be7d7724d11c984d11de76c2220aaae41502515f156e03aeca
+  data.tar.gz: d694be35c46f90866280700653aa35af66da37e9e3ec9bcf0724805b947550b0
 SHA512:
-  metadata.gz: 44a797e58abb32b6434cb83eec2d84270a6499dc3c8d986a6da1a68da1074982a9217655d20e835bd5fe8812c8780a7a9775a9495d970cf0eb849694b0d6d9d3
-  data.tar.gz: 0c410271301a481b5085d7be62a2f45de58eb7fe46cad199e69e0f0f017f7648f4646305f2853ce248c5f6c62979f31c8d7087b7526945234315b8b6b6f63833
+  metadata.gz: 86c6dc4296a5c63c074178cdb01f19b171403e895b02dfb6e9897da9db87288a143228a3a0d7631953ddcf19ce2199a3060440fbd7472c472507af952206496c
+  data.tar.gz: f0a27398ba13e4b352ccda7e3f810485577f5e2ac5154f2a4b43ab276ae6c2778877318f5c0c58e9ce92caa95ce2e27d10b11e829785cf61bb916fc1ac7bbccc

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

@@ -605,21 +605,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 +624,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 +638,22 @@ 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))
+            # 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|
@@ -978,6 +964,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.90"
 end

metadata

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