ea 0.6.93 → 0.6.94

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffc412a948388b91fc07382b857fdcdbb4fda6a6d12bdc4cba7931c29720bf2e
-  data.tar.gz: 06cf5da1fb2062d414866f36e03798cfc9052fb2fcae45dfb78552e754d07662
+  metadata.gz: d2c872554c2534df450bc335593fb39ed9363f3fe20053ef001b1621c5cdec6b
+  data.tar.gz: 79cecbb5a25a07a38d5bac1df1aaf413ffbc471cdd39938cd64cdf8bca822ce7
 SHA512:
-  metadata.gz: 3d498df6109da7ad7c4368b589f34c9dbe3a48171571e9993fef75d80874e3f1eb6a31e6f890db39c5f413a61e895da8e3bf7f81a6d01b94fdc0a225267fb809
-  data.tar.gz: ec4537e30476a83f7ecc39c29aacb1d54f6a788f9a87c97bfcf86f665ece6010ca640a31062d30c0ad2f1fa8362bc1e834f207355989b27f9197ede225eff54a
+  metadata.gz: d24168a33acbf362b4feff14508abb00562139e6602caed154c7f4b5e8bfa2b0f773b045fd27585f0610946f8fb2e4e9e6dbf2b8667ab785fc1bd71f18e9aa83
+  data.tar.gz: 1559678bc826ecdb82d710a72723709fa195907e8a11bb138eed728ba8b9804b30fcab7f75a024f27f8df34558ba52ec7f373e18bf1f46e6c7a89f07af8cf70b

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

@@ -34,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

@@ -646,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

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
@@ -177,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
@@ -204,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)
@@ -391,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/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.93"
+  VERSION = "0.6.94"
 end

metadata

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