ea 0.6.92 → 0.6.94

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 641441bf5b181aaadd045223f47a59069d916f48247f19ab4e6bc6c19cfeee03
-  data.tar.gz: 0eb407d782f28301f0747a2f251ce3412f97cc60882f87cc7062567d1e7e4a64
+  metadata.gz: d2c872554c2534df450bc335593fb39ed9363f3fe20053ef001b1621c5cdec6b
+  data.tar.gz: 79cecbb5a25a07a38d5bac1df1aaf413ffbc471cdd39938cd64cdf8bca822ce7
 SHA512:
-  metadata.gz: d705861a5209c8646e01fb097b4329e634744bdeef07355d00598a45bff1134ab186c69c0088250a3a3c5ece15d2c39281653c0e667a473fea80dbfd4bb9b9c0
-  data.tar.gz: 84fce6fa28c77169812dda317ef720035c1ac9b17ac854238aa376480980308b7c506e6f3fa52e23807e7cc851546fe65b0c6b8bda72b937b1d9a99ab82953ad
+  metadata.gz: d24168a33acbf362b4feff14508abb00562139e6602caed154c7f4b5e8bfa2b0f773b045fd27585f0610946f8fb2e4e9e6dbf2b8667ab785fc1bd71f18e9aa83
+  data.tar.gz: 1559678bc826ecdb82d710a72723709fa195907e8a11bb138eed728ba8b9804b30fcab7f75a024f27f8df34558ba52ec7f373e18bf1f46e6c7a89f07af8cf70b

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

@@ -8,6 +8,21 @@ module Ea
         module Routing
           private
 
+          # A lateral tree leaves the side edge before turning upward.
+          # Keep that dock only when its first leg actually points outward.
+          def lateral_source_exit?(points, link_row, bounds)
+            return false unless points.size == 3 && DiagramStyleParser.parse(link_row.style)[:tree] == "LV"
+
+            anchor, bend = points.take(2)
+            anchor[1] == bend[1] && outward_side_exit?(anchor[0], bend[0], bounds)
+          end
+
+          def outward_side_exit?(anchor_x, bend_x, bounds)
+            left = bounds.x
+            right = left + bounds.width
+            (anchor_x == left && bend_x < left) || (anchor_x == right && bend_x > right)
+          end
+
           # 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)
@@ -19,6 +34,50 @@ module Ea
             tree_bends_fit?(points[1], points[-2], src, tgt)
           end
 
+          # A width-2 Mode 3 horizontal tree keeps its stored vertical trunk
+          # and docks both ends on the facing sides' 1px outer outlines at
+          # the bend heights. Returns nil unless the trunk sits strictly
+          # inside the open gap and each bend lies inside its own box.
+          def horizontal_tree_route(points, link_row, connector, src, tgt)
+            return nil unless points.size == 4 && horizontal_tree_style?(link_row, connector)
+
+            first, last = points.values_at(1, 2)
+            src_x, tgt_x = facing_outline_xs(src, tgt)
+            return nil unless src_x && trunk_in_gap?(first, last, src_x, tgt_x)
+            return nil unless inside_height?(first[1], src) && inside_height?(last[1], tgt)
+
+            [[src_x, first[1]], first, last, [tgt_x, last[1]]]
+          end
+
+          def horizontal_tree_style?(link_row, connector)
+            style = DiagramStyleParser.parse(link_row.style)
+            %w[Generalization Aggregation].include?(connector.connector_type) &&
+              style[:tree] == "H" && style[:lwidth] == "2" && style[:mode] == "3"
+          end
+
+          def trunk_in_gap?(first, last, src_x, tgt_x)
+            first[0] == last[0] && first[1] != last[1] &&
+              first[0] > [src_x, tgt_x].min && first[0] < [src_x, tgt_x].max
+          end
+
+          def inside_height?(height, bounds)
+            height > bounds.y && height < bounds.y + bounds.height
+          end
+
+          # Source and target x on the facing sides' outer outlines, or nil
+          # when the boxes are not horizontally separated.
+          def facing_outline_xs(src, tgt)
+            source_left = src.x
+            source_right = source_left + src.width
+            target_left = tgt.x
+            target_right = target_left + tgt.width
+            if target_right < source_left
+              [source_left - 1, target_right + 1]
+            elsif source_right < target_left
+              [source_right + 1, target_left - 1]
+            end
+          end
+
           def tree_bends_fit?(first, last, source, target)
             first[0] != last[0] && first[1] == last[1] &&
               within_vertical_gap?(first[1], source, target) &&

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

@@ -577,9 +577,8 @@ module Ea
         #     describe the source-side and target-side bend offsets
         #     relative to the edge attachment points.
         #
-        # Path takes precedence when present — it's the authoritative
-        # routing. SX/SY/EX/EY are fallback for auto-routed direct
-        # connectors with at most one bend on each end.
+        # Custom-line Path takes precedence when present. Direct mode
+        # ignores old custom bends; SX/SY/EX/EY supply its endpoint ports.
         #
         # If we can't resolve the source or target element placement
         # for this diagram, we emit no waypoints (the connector will
@@ -607,8 +606,10 @@ module Ea
                          element_edge_point(target_placement, :target, edge_out)
 
           intermediate = intermediate_waypoints(link_row)
-          if edge_out == 2 && source_port && target_port &&
-             !valid_tree_path?(intermediate, source_placement)
+          if DiagramStyleParser.parse(link_row.style)[:mode] == "1"
+            points = [source_point, target_point]
+          elsif edge_out == 2 && source_port && target_port &&
+                !valid_tree_path?(intermediate, source_placement)
             # 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.
@@ -645,10 +646,13 @@ module Ea
           # 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
-            src = bounds_from_rect(source_placement)
-            tgt = bounds_from_rect(target_placement)
+          src = bounds_from_rect(source_placement)
+          tgt = bounds_from_rect(target_placement)
+          tree_route = horizontal_tree_route(points, link_row, connector, src, tgt)
+          if tree_route
+            points = tree_route
+          elsif %w[Association Aggregation].include?(connector.connector_type) &&
+                edge_out != 2
             unless preserve_stored_tree?(points, link_row, connector, src, tgt)
               points = facing_edge_route(points, src, tgt)
             end
@@ -923,7 +927,7 @@ module Ea
           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
+          unless lateral_source_exit?(points, link_row, src_b) || (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

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

@@ -3,7 +3,7 @@
 module Ea
   module Svg
     module EaEmitter
-      # Re-docks DIRECT (auto-routed straight, 2-waypoint) connectors
+      # Re-docks direct connectors and lateral tree target legs
       # against the DRAWN element outlines captured during the element
       # render pass. EA clips connector rays at drawn boxes — grown
       # classifier heights and autosized package bodies — never the
@@ -13,17 +13,15 @@ module Ea
       module ConnectorRedock
         module_function
 
-        # Returns replacement waypoint pairs [source_edge, target_edge]
+        # Returns replacement waypoint pairs for direct or lateral tree routes,
         # for the connector, or nil when the connector must keep its
         # parsed waypoints (not direct, not 2-point, unresolved ends,
         # self-loop, or no drawn bounds for either end).
         def pairs_for(connector, diagram, model_index, bounds_map)
           return nil unless bounds_map
-          return nil unless direct?(connector) || two_point?(connector)
-
           points = waypoint_pairs(connector)
-          return nil unless points.size == 2
-
+          lateral = lateral_tree?(connector, points)
+          return nil unless points.size == 2 || lateral
 
           rel = relationship_for(connector, model_index)
           return nil unless rel
@@ -36,6 +34,11 @@ module Ea
           return nil unless source_bounds && target_bounds
           return nil if source_ref == target_ref
 
+          if lateral
+            target = lateral_target(points[1], target_bounds, connector.style[:tree])
+            return target && [points[0], points[1], target]
+          end
+
           anchors = [connector.source_anchor, connector.target_anchor]
           bounds = [source_bounds, target_bounds]
           original = clipped_pairs(bounds, anchors)
@@ -50,6 +53,49 @@ module Ea
           forward_route?(original, candidate) ? candidate : original
         end
 
+        def lateral_tree?(connector, points)
+          style = connector.style.to_h
+          points.size == 3 && style[:mode] == "3" && style[:lwidth] == "2" &&
+            %w[LV LH].include?(style[:tree]) &&
+            %w[Generalization Aggregation].include?(connector.connector_type)
+        end
+        private_class_method :lateral_tree?
+
+        # The bend selects the near target edge even when the boxes overlap.
+        # Preserve the source leg and bend; only the final dock changes.
+        def lateral_target(bend, bounds, tree)
+          return nil unless bounds.width.positive? && bounds.height.positive?
+
+          tree == "LV" ? vertical_target(bend, bounds) : horizontal_target(bend, bounds)
+        end
+        private_class_method :lateral_target
+
+        def vertical_target(bend, bounds)
+          x, y = bend
+          return nil unless x.between?(bounds.x, bounds.x + bounds.width)
+
+          edge = facing_coordinate(y, bounds.y, bounds.height)
+          [x, edge] if edge
+        end
+        private_class_method :vertical_target
+
+        def horizontal_target(bend, bounds)
+          x, y = bend
+          return nil unless y.between?(bounds.y, bounds.y + bounds.height)
+
+          edge = facing_coordinate(x, bounds.x, bounds.width)
+          [edge, y] if edge
+        end
+        private_class_method :horizontal_target
+
+        def facing_coordinate(bend, start, extent)
+          return start if bend < start
+          return start + extent if bend > start + extent
+
+          nil
+        end
+        private_class_method :facing_coordinate
+
         def stroke_outline?(connector, bounds)
           connector.style.to_h[:lwidth] == "2" &&
             %w[Generalization Aggregation].include?(connector.connector_type) &&

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

@@ -21,6 +21,7 @@ module Ea
           PROPERTY_STEREOTYPE = "«Property»"
           SEAT_FONT_SIZE = 7
           SEAT_X_INSET = 3
+          SEAT_STEREOTYPE_GAP = 12
 
           attr_reader :canvas, :model_index, :document, :theme,
                       :font_family, :font_size, :font_unit
@@ -44,12 +45,22 @@ module Ea
           #   connector  - the DiagramConnector (for relationship lookup)
           #   end_kind   - :source or :target
           #   heading    - [dx, dy] of the first leg leaving the anchor
+          #   stored_labels - the connector has stored label boxes at
+          #                   either end; false keeps the opposite-end
+          #                   fallback
           def texts(text_box:, mult_box:, anchor:, connector:, end_kind:,
-                    tree: false, heading: nil)
+                    tree: false, heading: nil, stored_labels: false)
             from_property, role, mult = role_and_multiplicity(connector, end_kind)
             if role_empty?(role) && mult_empty?(mult)
               other_from_prop, other_role, other_mult = role_and_multiplicity(connector,
                                                               opposite(end_kind))
+              if stored_labels
+                return [] if role_empty?(other_role) && mult_empty?(other_mult)
+
+                return own_stereotype_only(text_box, anchor, connector,
+                                           end_kind)
+              end
+
               role = other_role if role_empty?(role)
               mult ||= other_mult
               from_property ||= other_from_prop
@@ -88,6 +99,19 @@ module Ea
 
           private
 
+          # With stored boxes on the connector, an end that carries no
+          # data of its own draws only its own stereotype; the data end
+          # draws the role and multiplicity; with no data anywhere nothing
+          # is drawn. Connectors with no stored box keep the opposite-end
+          # fallback.
+          def own_stereotype_only(text_box, anchor, connector, end_kind)
+            stereo = connector_source_dest_stereotype(connector, end_kind)
+            pos = position_at(text_box, anchor)
+            return [] if stereo.nil? || stereo.empty? || pos.nil?
+
+            [text_at(pos[0], pos[1], "«#{stereo}»")]
+          end
+
           # EA's tree-route label clusters (hand-verified against the
           # EA-published reference, SY 8542 with canvas=(0,0)):
           # source-end pairs stack at the exit point (role +3/-23,
@@ -154,8 +178,11 @@ module Ea
           end
 
           def source_seat?(end_kind, heading)
-            end_kind == :source && heading &&
-              font_size == SEAT_FONT_SIZE && font_unit == "pt"
+            end_kind == :source && heading && seat_font?
+          end
+
+          def seat_font?
+            font_size == SEAT_FONT_SIZE && font_unit == "pt"
           end
 
           # Boxes with explicit string-keyed OX/OY (the QEA shape) that
@@ -181,7 +208,7 @@ module Ea
               texts = [text_at(x, y, role)]
               if stereo
                 stereo_x = x + stereotype_offset(role, stereo, text_box)
-                texts << text_at(stereo_x, y + property_y_offset, stereo)
+                texts << text_at(stereo_x, y + property_y_offset(text_box), stereo)
               end
               if mult && !mult.empty? && mult_pos
                 texts << text_at(*mult_pos, mult)
@@ -368,7 +395,13 @@ module Ea
             [anchor[0] + offset_x.to_i, anchor[1] - offset_y.to_i]
           end
 
-          def property_y_offset
+          # The stereotype line sits 12px below the role on 7pt labels
+          # with default presentation;
+          # other sizes and custom presentation keep size + 6.
+          def property_y_offset(text_box)
+            return SEAT_STEREOTYPE_GAP if seat_font? && text_box &&
+                                          default_presentation?(text_box)
+
             font_size + 6
           end
 

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

@@ -79,19 +79,22 @@ module Ea
           tree = tree_shaped?(points)
 
           stored_src = end_boxes(boxes, :llt, :llb)
+          stored_tgt = end_boxes(boxes, :lrt, :lrb)
+          stored_labels = !(stored_src.nil? && stored_tgt.nil?)
           src_tb, src_mb = stored_src || default_label_boxes(points, :source)
-          tgt_tb, tgt_mb = end_boxes(boxes, :lrt, :lrb) ||
-                           default_label_boxes(points, :target)
+          tgt_tb, tgt_mb = stored_tgt || default_label_boxes(points, :target)
 
           texts = []
           end_renderer.texts(text_box: src_tb, mult_box: src_mb,
                              anchor: source_pt, connector: connector,
                              end_kind: :source, tree: tree && tree[:source],
-                             heading: stored_src && leg_heading(points)).each { |t| texts << t }
+                             heading: stored_src && leg_heading(points),
+                             stored_labels: stored_labels).each { |t| texts << t }
           end_renderer.texts(text_box: tgt_tb,
                              mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
-                             end_kind: :target, tree: tree && tree[:target]).each { |t| texts << t }
+                             end_kind: :target, tree: tree && tree[:target],
+                             stored_labels: stored_labels).each { |t| texts << t }
           texts
         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.92"
+  VERSION = "0.6.94"
 end

metadata

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