ea 0.6.33 → 0.6.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e63b36fde438e5d088ee091f1a7e9612eb93d379d066d3abaebca6e3495b3d16
-  data.tar.gz: fbe7073cfddcd4bb861cb7ea238ea436a7f3f5bab5d661e928b2df596bdde92a
+  metadata.gz: dd78b24ea3d07ae30617251edd34bab2723f35af5c996b60986bcc87852baed5
+  data.tar.gz: 032f878a8b3d21ee10437df152fa93bbabb22453b8172a3073f17c60b1a1ca8d
 SHA512:
-  metadata.gz: e1a3392ff7069a1c9287e94997c9d516ac5ee358fb66f76bf27a310615bcaad6e4daeffb135bbda464976e6cccf24e9d40999fabbec64c2f3a863e0bb5b60b3d
-  data.tar.gz: 55d8d38d9bc7d613f0673863b6f6ace24bad435d1e59b9662fada852bc38248abcacb5f211f466566b668abfcb7a368c129a57e34b58b389d6621a8b5fa13cde
+  metadata.gz: ae990b9d896f3b9f82aabdb1285814aa7163b3a202ec070aa5cb42d732e4a4c333e03f07ef4f7d283c71133dad904879328da646052804dfaacbea2d08782bd6
+  data.tar.gz: 994415d780dafd15502b5d64ea7e0a8049a1cc9932a94dce2351a76b79f8fecc80a4cbfcd691409d90048d5c9b8485eb857b53e5fa682c5711b84fd34e0e49de

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

@@ -187,7 +187,11 @@ module Ea
             # and associations draw as plain source-first lines
             # (0CABA7D7's gen "M 125 130 L 125 99"; 568CDFC9's
             # regenerated assocs).
-            style: conn.connector_type == "Dependency" ? { direct: true } : {},
+            style: if conn.connector_type == "Dependency"
+                     { direct: true, regenerated: true }
+                   else
+                     { regenerated: true }
+                   end,
             hidden: false,
             has_geometry_offsets: false
           )

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

@@ -59,7 +59,27 @@ module Ea
         # Element x-extent: logical bounds only (matches EA's canvas
         # left/right exactly).
         # Element y-extent: union of logical + image_bounds (image
-        # extends below bounds for shadow / image padding).
+        # extends below bounds for shadow / image padding), plus the
+        # "(from Parent)" subtitle extent: EA draws the subtitle 15px
+        # below the body and its text descent adds ~4 more, reserving
+        # 19px of canvas below subtitle-bearing packages (the +19
+        # height family: 05DF5000 Main, Metadata All, package
+        # Clients/Suppliers contexts).
+        SUBTITLE_CANVAS_EXTRA = 19
+
+        def subtitle_points
+          pts = []
+          (diagram.elements || []).each do |e|
+            primary = e.bounds || e.image_bounds
+            next unless primary
+            next unless subtitle_extends_below?(e)
+
+            pts << [primary.x, primary.y + primary.height +
+                                 SUBTITLE_CANVAS_EXTRA]
+          end
+          pts
+        end
+
         def element_points
           pts = []
           (diagram.elements || []).each do |e|
@@ -67,6 +87,10 @@ module Ea
             if primary
               pts << [primary.x, primary.y]
               pts << [primary.x + primary.width, primary.y + primary.height]
+              if subtitle_extends_below?(e)
+                pts << [primary.x, primary.y + primary.height +
+                                     SUBTITLE_CANVAS_EXTRA]
+              end
             end
             if e.bounds && e.image_bounds
               ib = e.image_bounds
@@ -76,6 +100,24 @@ module Ea
           end
           pts
         end
+
+        # Mirrors Compartment::PackageFromParent's render conditions:
+        # the subtitle draws only on ShowForeign diagrams for a
+        # placed package whose parent differs from the diagram's
+        # package.
+        def subtitle_extends_below?(element)
+          return false unless model_index
+          return false unless diagram.show_foreign
+
+          pkg = model_index[element.model_element_ref]
+          return false unless pkg.is_a?(Ea::Model::Package)
+
+          parent_id = pkg.parent_id
+          return false if parent_id.nil? || parent_id.empty?
+          return false if parent_id == diagram.package_id
+
+          model_index[parent_id].is_a?(Ea::Model::Package)
+        end
       end
     end
   end

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

@@ -42,6 +42,33 @@ module Ea
           new(min_x: min_x, min_y: min_y, width: width, height: height)
         end
 
+        # Second-pass canvas over the DRAWN extents captured by the
+        # element pass (grown classifiers, autosized packages, plus
+        # BoundsCalculator's subtitle reservation). EA sizes the
+        # canvas from drawn extents, so diagrams whose lowest/rightmost
+        # element grew get a taller/wider canvas than the stored-rect
+        # first pass provides.
+        def self.from_drawn(diagram, drawn_bounds, model_index: nil)
+          base = BoundsCalculator.new(diagram, model_index: model_index)
+          pts = []
+          drawn_bounds.each_value do |b|
+            pts << [b.x, b.y]
+            pts << [b.x + b.width, b.y + b.height]
+          end
+          extra = base.send(:subtitle_points)
+          min_x = (pts + extra).map(&:first).min || 0
+          min_y = (pts + extra).map(&:last).min || 0
+          max_x = (pts + extra).map(&:first).max || 0
+          max_y = (pts + extra).map(&:last).max || 0
+          return from(diagram, model_index: model_index) if pts.empty?
+
+          new(min_x: min_x, min_y: min_y,
+              width: (max_x - min_x) + BoundsCalculator::INSET_LEFT +
+                     BoundsCalculator::INSET_RIGHT,
+              height: (max_y - min_y) + BoundsCalculator::INSET_TOP +
+                      BoundsCalculator::INSET_BOTTOM)
+        end
+
         def view_box
           "0 0 #{width} #{height}"
         end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Re-docks DIRECT (auto-routed straight, 2-waypoint) connectors
+      # 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
+      # stored logical rect (E58034A3: supplier right-edge dock 155
+      # drawn vs 121 stored; 0CABA7D7's generalization far end 99
+      # grown vs 84 stored).
+      module ConnectorRedock
+        module_function
+
+        # Returns replacement waypoint pairs [source_edge, target_edge]
+        # 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)
+
+          points = waypoint_pairs(connector)
+          return nil unless points.size == 2
+
+          rel = relationship_for(connector, model_index)
+          return nil unless rel
+
+          source_ref, target_ref = end_refs(rel)
+          return nil unless source_ref && target_ref
+
+          source_bounds = bounds_map[source_ref]
+          target_bounds = bounds_map[target_ref]
+          return nil unless source_bounds && target_bounds
+          return nil if source_ref == target_ref
+
+          [edge_point(source_bounds, target_bounds),
+           edge_point(target_bounds, source_bounds)]
+        end
+
+        def direct?(connector)
+          style = connector.style || {}
+          %i[direct regenerated].any? { |k| style.key?(k) } ||
+            %w[direct regenerated].any? { |k| style.key?(k) }
+        end
+
+        def waypoint_pairs(connector)
+          (connector.waypoints || []).filter_map do |wp|
+            next unless wp.position
+
+            [wp.position.x, wp.position.y]
+          end
+        end
+
+        def relationship_for(connector, model_index)
+          return nil unless connector.relationship_ref && model_index
+
+          model_index[connector.relationship_ref]
+        end
+
+        # Polymorphic relationship ends, in connector start→end
+        # order: Generalization child→parent (specific_id/general_id),
+        # Dependency client→supplier (client_id/supplier_id),
+        # Association source_id/target_id.
+        def end_refs(rel)
+          if rel.respond_to?(:specific_id)
+            [rel.specific_id, rel.general_id]
+          elsif rel.respond_to?(:client_id)
+            [rel.client_id, rel.supplier_id]
+          else
+            [rel.source_id, rel.target_id]
+          end
+        end
+
+        # Center-to-center ray clipped at both box outlines.
+        def edge_point(bounds, other_bounds)
+          cx = bounds.x + bounds.width / 2
+          cy = bounds.y + bounds.height / 2
+          ocx = other_bounds.x + other_bounds.width / 2
+          ocy = other_bounds.y + other_bounds.height / 2
+
+          dx = ocx - cx
+          dy = ocy - cy
+
+          if dx.abs * bounds.height > dy.abs * bounds.width
+            x = dx.positive? ? bounds.x + bounds.width : bounds.x
+            y = safe_y(cx, cy, dx, dy, x)
+            [x, y]
+          else
+            y = dy.positive? ? bounds.y + bounds.height : bounds.y
+            x = safe_x(cx, cy, dx, dy, y)
+            [x, y]
+          end
+        end
+
+        def safe_y(cx, cy, dx, dy, x)
+          return cy if dx.zero?
+
+          cy + dy * (x - cx).abs / dx.abs
+        end
+
+        def safe_x(cx, cy, dx, dy, y)
+          return cx if dy.zero?
+
+          cx + dx * (y - cy).abs / dy.abs
+        end
+      end
+    end
+  end
+end

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

@@ -16,13 +16,17 @@ module Ea
       class Connectors
         LINE_STYLE_KEY = :connector_line
 
-        attr_reader :diagram, :canvas, :grouped, :stroke_width
+        attr_reader :diagram, :canvas, :grouped, :stroke_width, :drawn_bounds,
+                    :model_index
 
-        def initialize(diagram, canvas: nil, grouped: true, stroke_width: 2)
+        def initialize(diagram, canvas: nil, grouped: true, stroke_width: 2,
+                       drawn_bounds: nil, model_index: nil)
           @diagram = diagram
           @canvas = canvas
           @grouped = grouped
           @stroke_width = stroke_width
+          @drawn_bounds = drawn_bounds
+          @model_index = model_index
         end
 
         def layers
@@ -55,7 +59,9 @@ module Ea
         end
 
         def path_for(connector)
-          pts = waypoints_for(connector)
+          pts = ConnectorRedock.pairs_for(connector, diagram, model_index,
+                                          drawn_bounds) ||
+                waypoints_for(connector)
           return nil if pts.size < 2
 
           # DIRECT (auto-routed straight) connectors: EA writes the

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

@@ -21,11 +21,25 @@ module Ea
 
         def render
           canvas = Canvas.from(diagram, model_index: model_index)
-          layers = LayerSequencer.new(diagram, model_index: model_index,
-                                        canvas: canvas, frame: frame,
-                                        document: document)
-                                  .layers
-                                  .reject { |s| s.nil? || s.empty? }
+          seq = LayerSequencer.new(diagram, model_index: model_index,
+                                   canvas: canvas, frame: frame,
+                                   document: document)
+          seq.layers
+          # Second pass over the DRAWN extents: grown classifiers and
+          # autosized packages can exceed the stored-rect canvas EA
+          # sizes from drawn extents. Skip when the first pass already
+          # covers the drawn extents (the common case).
+          grown = seq.drawn_bounds
+          if grown && grown.values.any? &&
+             exceeds?(canvas, grown.values)
+            canvas = Canvas.from_drawn(diagram, grown,
+                                       model_index: model_index)
+            seq = LayerSequencer.new(diagram, model_index: model_index,
+                                     canvas: canvas, frame: frame,
+                                     document: document)
+            seq.layers
+          end
+          layers = seq.layers.reject { |s| s.nil? || s.empty? }
           image_layer = emit_images
           layers << image_layer if image_layer
 
@@ -55,6 +69,16 @@ module Ea
           %(<g id="images">\n#{fragments.join("\n")}\n</g>)
         end
 
+        # True when any drawn bound falls outside the stored-rect
+        # canvas content area.
+        def exceeds?(canvas, bounds)
+          bounds.any? do |b|
+            b.x < canvas.min_x || b.y < canvas.min_y ||
+              b.x + b.width > canvas.min_x + canvas.width ||
+              b.y + b.height > canvas.min_y + canvas.height
+          end
+        end
+
         def render_image(image)
           svg = Ea::Image::EmfRenderer.render(image.bytes)
           return nil unless svg

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

@@ -31,9 +31,17 @@ module Ea
         # Each element contributes up to 4 groups (shape, header,
         # divider, attrs) in EA's per-entity layer order.
         def groups
+          @drawn_bounds = {}
           ordered_elements.flat_map { |e| groups_for(e) }
         end
 
+        # Final drawn Bounds per model element reference, captured
+        # during rendering (grown heights for overflowing classifiers,
+        # autosized outlines for packages). Connector emission re-docks
+        # direct lines against these — EA clips connector rays at the
+        # drawn outlines, never the stored rect.
+        attr_reader :drawn_bounds
+
         private
 
         def ordered_elements
@@ -46,9 +54,45 @@ module Ea
           context = build_context(element)
           return [] unless context
 
+          record_drawn_bounds(element, context)
           Compartment.render_all(context).compact
         end
 
+        # Logical-space drawn bounds: stored x/y with the RENDERED
+        # height (grown classifiers) and rendered width (autosized
+        # packages). Heights/widths are translation-invariant, so the
+        # connector emitters can redock in logical space and run the
+        # normal canvas translation afterwards.
+        def record_drawn_bounds(element, context)
+          return unless element.model_element_ref
+
+          raw = element.bounds || element.image_bounds
+          return unless raw
+
+          width = raw.width
+          if classifier_package?(context.classifier)
+            tab = Element::PackageShapeRenderer.autosized_tab_width(
+              label: context.classifier.name.to_s,
+              stereotype: package_stereotype(context),
+              size: context.size
+            )
+            width = tab + Element::PackageShapeRenderer::TAB_BODY_EXTRA
+          end
+          @drawn_bounds[element.model_element_ref] = Ea::Model::Bounds.new(
+            x: raw.x, y: raw.y,
+            width: width,
+            height: context.bounds.height
+          )
+        end
+
+        def classifier_package?(classifier)
+          classifier.class == Ea::Model::Package
+        end
+
+        def package_stereotype(context)
+          context.classifier.stereotype_refs.first.to_s
+        end
+
         # Build the RenderContext for one element. Returns nil when
         # the element has no usable bounds (skip rendering).
         def build_context(element)

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

@@ -42,6 +42,13 @@ module Ea
           layers
         end
 
+        # Final drawn Bounds per model element ref (grown heights,
+        # autosized packages) captured by the element pass; connector
+        # emission re-docks direct lines against these.
+        def drawn_bounds
+          @elements&.drawn_bounds
+        end
+
         private
 
         def frame_layers
@@ -49,17 +56,22 @@ module Ea
         end
 
         def element_layers
-          Elements.new(diagram, model_index: model_index, canvas: canvas,
-                        document: document).groups
+          @elements = Elements.new(diagram, model_index: model_index,
+                                             canvas: canvas,
+                                             document: document)
+          @elements.groups
         end
 
         def connector_layers
           connector_layers_raw = Connectors.new(diagram, canvas: canvas,
                                                   grouped: true,
-                                                  stroke_width: DEFAULT_STROKE_WIDTH).layers
+                                                  stroke_width: DEFAULT_STROKE_WIDTH,
+                                                  drawn_bounds: drawn_bounds,
+                                                  model_index: model_index).layers
           marker_layers_raw = Markers.new(diagram, model_index: model_index,
                                            canvas: canvas, grouped: true,
-                                           stroke_width: DEFAULT_STROKE_WIDTH).layers
+                                           stroke_width: DEFAULT_STROKE_WIDTH,
+                                           drawn_bounds: drawn_bounds).layers
           merge_layers_by_style(connector_layers_raw + marker_layers_raw).map(&:to_svg)
         end
 

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

@@ -31,14 +31,17 @@ module Ea
         DEP_ARROW_HALF_BASE = 5
         DEP_ARROW_HEIGHT = 15
 
-        attr_reader :diagram, :model_index, :canvas, :grouped, :stroke_width
+        attr_reader :diagram, :model_index, :canvas, :grouped, :stroke_width,
+                    :drawn_bounds
 
-        def initialize(diagram, model_index:, canvas: nil, grouped: true, stroke_width: 2)
+        def initialize(diagram, model_index:, canvas: nil, grouped: true,
+                       stroke_width: 2, drawn_bounds: nil)
           @diagram = diagram
           @model_index = model_index
           @canvas = canvas
           @grouped = grouped
           @stroke_width = stroke_width
+          @drawn_bounds = drawn_bounds
         end
 
         def layers
@@ -454,6 +457,10 @@ module Ea
         end
 
         def waypoint_pairs(connector)
+          redocked = ConnectorRedock.pairs_for(connector, diagram,
+                                               model_index, drawn_bounds)
+          return redocked if redocked
+
           (connector.waypoints || []).filter_map do |w|
             next unless w.position
 

data/lib/ea/svg/ea_emitter.rb

@@ -45,6 +45,7 @@ module Ea
       autoload :Document, "ea/svg/ea_emitter/document"
       autoload :Label, "ea/svg/ea_emitter/label"
       autoload :Compartment, "ea/svg/ea_emitter/compartment"
+      autoload :ConnectorRedock, "ea/svg/ea_emitter/connector_redock"
       autoload :RenderContext, "ea/svg/ea_emitter/render_context"
       autoload :VisibilitySymbol, "ea/svg/ea_emitter/visibility_symbol"
     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.33"
+  VERSION = "0.6.35"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.33
+  version: 0.6.35
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-04 00:00:00.000000000 Z
+date: 2026-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -894,6 +894,7 @@ files:
 - lib/ea/svg/ea_emitter/compartment/shape.rb
 - lib/ea/svg/ea_emitter/compartment/stereotype_icon.rb
 - lib/ea/svg/ea_emitter/compartment/tagged_values.rb
+- lib/ea/svg/ea_emitter/connector_redock.rb
 - lib/ea/svg/ea_emitter/connectors.rb
 - lib/ea/svg/ea_emitter/diagram_frame.rb
 - lib/ea/svg/ea_emitter/document.rb