ea 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8a117bfcfdfe9fe4ace5104c3db01fc2ee338bc8a49654be3a5dd8794c9ed98
-  data.tar.gz: 2cc7a8fe2d505872db1bd5ba02e2c951556838b08368ba697aafc19ae3d075d8
+  metadata.gz: 9d4eb047626f932a223d59f60d7a07ac839542e16f1f08cc1e27f99102592af7
+  data.tar.gz: d38407abf49dd80a886269968e944edfa691bc09ca31772556d8d20a89dac294
 SHA512:
-  metadata.gz: 9b9d9a7fe445ba715bbf7fea49a8b20f5a29258bbed87808a4e62ebbce1a63186651d41f780e451042a7a80e4c2b41b390c070bb33f479be9a2f831348e9c748
-  data.tar.gz: d31530d3396479880099baa74bc73858229d2c6fa69108b23ddffc0bb45f550737ada00924e6a1e22c594e532d3d531745c7cfb40af226c1266291fbe9250fef
+  metadata.gz: 50d22ea166bdb5ee80f60a16d2396dc12b90470d1c9f5048279ee9e9d4233b7778af481f04719618416f59d26ada1ddb750bbda03e8fd9f6c4abc1c279ecd9a1
+  data.tar.gz: 9ac1166cc762bce236ca889b8a28f26bb32f3688fa00ce925b53f91adf5999976057aefe91e4b684fdf55adbca352af6bd4f5901e9b5251ba0b29c21999becd5

data/CHANGELOG.md

@@ -7,6 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- `Ea::Model::DiagramConnector` now carries `source_port` / `target_port`
+  — the absolute connection points EA docks each connector endpoint
+  at, derived from the `t_diagramlinks.Geometry` SX/SY and EX/EY
+  offsets by ray-casting from the element center through
+  center+offset to the box border (fixes #52; semantics verified
+  against EA-published reference SVGs). QEA-built connectors route
+  from these ports instead of edge-midpoint guesses, so arrows and
+  aggregation diamonds terminate on the element border exactly where
+  EA places them.
+- QEA `diagram_builder` maps per-element `font_size` (EA's tenth-point
+  `fontsz`, custom values only) and `font_underline` from the
+  objectstyle string (fixes #53).
+- `Ea::Svg::Parity::Checker` compares font-family and font-size
+  histograms across all emitted text (was: first-text only), so a
+  single wrong-size compartment fails the parity check (#54).
+
+### Fixed
+- QEA diagram coordinates are now mirrored into EA's screen-down
+  space at build time (stored t_diagramobjects rects are bottom-up;
+  EA's own published SVGs draw the mirrored view). Connector ports,
+  Path waypoints, and bend fallbacks flip consistently, so SVG and
+  SPA output matches EA's orientation exactly.
+- Element font sizes stored as EA's classic defaults (fontsz 80/90)
+  are treated as use-default markers: rendering falls back to the
+  7pt theme size EA actually emits, and only genuinely custom sizes
+  override it.
+- Attribute multiplicity bounds stored as EA's "n" no longer parse
+  to 1 (which silently dropped the `[1..n]` suffix); unbounded
+  uppers render as `[1..n]` like EA.
+- `Ea::Svg::EaEmitter::TextRenderer` no longer raises
+  `TypeError: can't convert nil into Float` on degenerate placements
+  with missing coordinates or font size — it renders at the origin
+  with zero-width estimation instead (fixes #51; 297 of 3,702 PLATEAU
+  CG3 diagrams previously crashed `ea svg --all` and shipped without
+  SVG in SPA output).
+
+## [0.6.4]
+
 ### Added
 - `Ea::Spa::Projector` embeds model statistics (packages, classes,
   attributes, operations, associations, diagrams) in the skeleton

data/config/themes/119.yml

@@ -38,7 +38,7 @@ strokes:
 # Text geometry — EA uses GDI text metrics for exact widths. We
 # approximate with character_count * size * factor.
 text_metrics:
-  width_factor: 0.65
+  width_factor: 0.612
 
 # Canvas frame insets (EA places element (0,0) at SVG (left, top)).
 canvas:
@@ -60,10 +60,10 @@ frame:
 # diagram byte-diff: element at y=40 size=9, stereotype y=58 →
 # offset = 18 = size * 2; name y=73 → line_h = size + 6).
 compartments:
-  header_top_padding: 9
+  header_top_padding: 12
   header_line_offset: 6
   divider_offset: 8
-  attr_line_offset: 4
+  attr_line_offset: 6
   attr_first_offset: 7
   op_line_offset: 4
   op_line_offset: 4
@@ -71,7 +71,7 @@ compartments:
 # Attribute text x-offsets within element bounds.
 attribute:
   visibility_x_offset: 5
-  content_x_offset: 26
+  content_x_offset: 22
 
 # Marker geometry constants.
 markers:

data/lib/ea/model/diagram_connector.rb

@@ -33,6 +33,13 @@ module Ea
       # connectors (no SX/SY) get a plain solid line.
       attribute :has_geometry_offsets, :boolean, default: false
 
+      # Absolute connection points on the source/target element boxes,
+      # derived from the Geometry SX/SY and EX/EY edge offsets. EA
+      # docks the connector's visible endpoints at these ports; nil
+      # when the geometry string carries no offsets (auto-routed).
+      attribute :source_port, Ea::Model::Point
+      attribute :target_port, Ea::Model::Point
+
       json do
         map "id", to: :id
         map "diagramId", to: :diagram_id
@@ -43,6 +50,8 @@ module Ea
         map "targetDuid", to: :target_duid
         map "sourceEdge", to: :source_edge
         map "targetEdge", to: :target_edge
+        map "sourcePort", to: :source_port
+        map "targetPort", to: :target_port
         map "connectorType", to: :connector_type
         map "direction", to: :direction
         map "waypoints", to: :waypoints, render_empty: true

data/lib/ea/model/property.rb

@@ -12,7 +12,11 @@ module Ea
       attribute :type_name, :string             # name shown when type is external/primitive
       attribute :qualified_name, :string
       attribute :multiplicity_lower, :integer
-      attribute :multiplicity_upper, :integer   # -1 means "many"
+      attribute :multiplicity_upper, :integer
+      # Verbatim stored bound text (e.g. EA's literal "n") when the
+      # column value is non-numeric; rendered as-is by the SVG line
+      # builder while computed-unbounded uppers render as "*".
+      attribute :multiplicity_upper_raw, :string   # -1 means "many"
       attribute :default_value, :string
       attribute :is_derived, :boolean, default: false
       attribute :is_readonly, :boolean, default: false
@@ -33,6 +37,7 @@ module Ea
         map "typeName", to: :type_name
         map "qualifiedName", to: :qualified_name
         map "multiplicityLower", to: :multiplicity_lower
+        map "multiplicityUpperRaw", to: :multiplicity_upper_raw
         map "multiplicityUpper", to: :multiplicity_upper
         map "defaultValue", to: :default_value
         map "isDerived", to: :is_derived, render_default: true

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

@@ -155,8 +155,10 @@ module Ea
 
         def build_assoc_property(conn, role, owner_object)
           target = database.find_object(conn.end_object_id) if conn.end_object_id&.to_i&.positive?
+          guid = IdNormalizer.from_guid(conn.ea_guid)
           Ea::Model::Property.new(
-            id: IdNormalizer.from_guid(conn.ea_guid),
+            id: guid,
+            association_id: guid,
             name: role,
             owner_id: IdNormalizer.from_guid(owner_object.ea_guid),
             type_name: target&.name,

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

@@ -92,9 +92,11 @@ module Ea
             model_element_ref: ref_for_object(obj_row),
             bounds: bounds_from_rect(obj_row),
             style: style_hash,
-            font_family: style_hash[:font],
+            font_family: presence(style_hash[:font]),
+            font_size: font_size_from(style_hash),
             font_bold: truthy?(style_hash[:bold]),
             font_italic: truthy?(style_hash[:italic]),
+            font_underline: truthy?(style_hash[:ul]),
             show_tagged_values: truthy?(style_hash[:tag])
           )
         end
@@ -103,6 +105,28 @@ module Ea
           raw == "1" || raw == "-1"
         end
 
+        def presence(value)
+          value.nil? || value.to_s.empty? ? nil : value
+        end
+
+        # EA stores the element font size in tenths of a point in the
+        # objectstyle string. 0 means "use default", and 80/90 (8pt /
+        # 9pt) are EA's classic defaults the dialogs write back when
+        # the user never customized — verified against EA-published
+        # reference images, where such elements render at the theme
+        # size. Only genuinely custom sizes are surfaced as explicit
+        # element fonts.
+        USE_DEFAULT_FONTSZ = [0, 80, 90].freeze
+
+        def font_size_from(style_hash)
+          raw = style_hash[:fontsz]
+          return nil if raw.nil? || raw.to_s.empty?
+
+          return nil if USE_DEFAULT_FONTSZ.include?(raw.to_i)
+
+          (raw.to_f / 10).round
+        end
+
         def build_connectors(diagram_row)
           links = database.diagram_links_for(diagram_row.diagram_id) || []
           explicit = links.map { |link_row| build_connector(link_row, diagram_row) }
@@ -216,6 +240,8 @@ module Ea
             connector_type: connector&.connector_type,
             direction: connector&.direction,
             waypoints: waypoints_for_link(link_row, diagram_row),
+            source_port: connection_port(diagram_row, connector, :source, geom),
+            target_port: connection_port(diagram_row, connector, :target, geom),
             label_boxes: geom[:label_boxes] || {},
             style: DiagramStyleParser.parse(link_row.style),
             hidden: hidden?(link_row),
@@ -340,12 +366,22 @@ module Ea
           geom = parse_geometry_fields(link_row.geometry)
           edge_out = geom[:edge] || 0
 
-          source_point = element_edge_point(source_placement, :source, edge_out)
-          target_point = element_edge_point(target_placement, :target, edge_out)
+          source_port = connection_port(diagram_row, connector, :source, geom)
+          target_port = connection_port(diagram_row, connector, :target, geom)
+          # Waypoint points flow through this method as [x, y] arrays;
+          # keep the ports in the same shape.
+          source_point = source_port ? [source_port.x, source_port.y] :
+                         element_edge_point(source_placement, :source, edge_out)
+          target_point = target_port ? [target_port.x, target_port.y] :
+                         element_edge_point(target_placement, :target, edge_out)
 
           intermediate = intermediate_waypoints(link_row)
           if intermediate.any?
             points = [source_point, *intermediate, target_point]
+          elsif source_port || target_port
+            # Exact ports are known — the SX/SY bend heuristics in
+            # sx_sy_ex_ey_waypoints would double-apply the offsets.
+            points = [source_point, target_point]
           else
             points = sx_sy_ex_ey_waypoints(source_point, target_point, geom)
           end
@@ -355,13 +391,53 @@ module Ea
           end
         end
 
+        # Absolute connection point EA docks the connector's visible
+        # endpoint at, derived from the Geometry SX/SY (source) and
+        # EX/EY (target) offsets. The offsets are measured inward from
+        # the placed object's box edges — the X offset counts from the
+        # edge FACING the other end (source: right edge for positive
+        # values, left edge for negative; target mirrored), while the
+        # Y offset counts from the top edge for positive values and
+        # from the bottom edge for negative. Derived and verified
+        # against EA's own rendering on the PLATEAU models.
+        def connection_port(diagram_row, connector, end_kind, geom)
+          return nil unless connector
+
+          ea_object_id = end_kind == :source ? connector.start_object_id : connector.end_object_id
+          placement = ea_object_id &&
+                      diagram_object_placement(diagram_row.diagram_id, ea_object_id)
+          return nil unless placement
+
+          x_off = geom[end_kind == :source ? :sx : :ex]
+          y_off = geom[end_kind == :source ? :sy : :ey]
+          return nil if x_off.nil? || y_off.nil?
+
+          # EA's SX/SY and EX/EY are the offset of the docking line's
+          # direction from the element's CENTER (stored math coords,
+          # y up): the port is where the ray from the center through
+          # center+offset crosses the box border. Verified against
+          # EA-published reference SVGs. Bounds are already mirrored
+          # to screen-down space, so the offset's Y negates too.
+          b = bounds_from_rect(placement)
+          center_x = b.x + b.width / 2.0
+          center_y = b.y + b.height / 2.0
+          dx = x_off.to_f
+          dy = -y_off.to_f
+          return nil if dx.zero? && dy.zero?
+
+          tx = dx.zero? ? Float::INFINITY : (dx > 0 ? b.x + b.width - center_x : b.x - center_x) / dx
+          ty = dy.zero? ? Float::INFINITY : (dy > 0 ? b.y + b.height - center_y : b.y - center_y) / dy
+          t = [tx, ty].min
+          Ea::Model::Point.new(x: (center_x + t * dx).round, y: (center_y + t * dy).round)
+        end
+
         # Parse t_diagramlinks.Path into [[x, y], ...] intermediate
         # waypoints. Format: `x1:y1;x2:y2;...`. Empty string returns [].
         def intermediate_waypoints(link_row)
           raw = link_row.path.to_s
           return [] if raw.empty?
 
-          raw.scan(/(-?\d+):(-?\d+)/).map { |x, y| [x.to_i, y.to_i] }
+          raw.scan(/(-?\d+):(-?\d+)/).map { |x, y| [x.to_i, -y.to_i] }
         end
 
         # Fallback when no explicit Path: compute source/target bend
@@ -369,10 +445,10 @@ module Ea
         def sx_sy_ex_ey_waypoints(source_point, target_point, geom)
           points = [source_point]
           if geom[:sx] && geom[:sy] && (geom[:sx].nonzero? || geom[:sy].nonzero?)
-            points << [source_point[0] + geom[:sx], source_point[1] + geom[:sy]]
+            points << [source_point[0] + geom[:sx], source_point[1] - geom[:sy]]
           end
           if geom[:ex] && geom[:ey] && (geom[:ex].nonzero? || geom[:ey].nonzero?)
-            points << [target_point[0] - geom[:ex], target_point[1] - geom[:ey]]
+            points << [target_point[0] - geom[:ex], target_point[1] + geom[:ey]]
           end
           points << target_point
           points
@@ -427,6 +503,10 @@ module Ea
         end
         public :parse_label_boxes
 
+        # Pure helpers exposed for specs and consumers — no database
+        # access, safe to call in isolation.
+        public :font_size_from, :connection_port
+
         # Parse one label box's colon-separated key=value body into
         # a Hash with string keys. Returns nil if OX/OY are absent.
         def parse_label_style(body)
@@ -509,8 +589,10 @@ module Ea
         # EA's t_diagramobjects stores rect with the origin at the
         # bottom-left (math convention) — recttop > rectbottom for
         # valid bounds, and y values are often negative. Convert to
-        # screen-space (origin top-left) by taking min/max and using
-        # absolute width/height.
+        # screen-space (origin top-left, y increasing downward) by
+        # mirroring: EA's own SVG export draws the model mirrored, so
+        # the flipped top edge is -(max(top, bottom)); verified
+        # against EA-published reference images (dx=0, dy=-mirror).
         def bounds_from_rect(obj_row)
           left = obj_row.rectleft || 0
           right = obj_row.rectright || 0
@@ -518,7 +600,7 @@ module Ea
           bottom = obj_row.rectbottom || 0
           Ea::Model::Bounds.new(
             x: [left, right].min,
-            y: [top, bottom].min,
+            y: -[top, bottom].max,
             width: (right - left).abs,
             height: (bottom - top).abs
           )

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

@@ -27,6 +27,7 @@ module Ea
             type_name: row.type,
             qualified_name: "#{owner_object.name}::#{row.name}",
             multiplicity_lower: parse_lower(row),
+            multiplicity_upper_raw: raw_upper(row),
             multiplicity_upper: parse_upper(row),
             default_value: row.default,
             is_ordered: boolean(row.isordered),
@@ -42,6 +43,14 @@ module Ea
 
         private
 
+        # EA stores some bounds as literal text ("n"); those render
+        # verbatim in attribute lines while computed-unbounded bounds
+        # render as "*" (verified against EA-published SVGs).
+        def raw_upper(row)
+          raw = row.upperbound.to_s
+          raw.match?(/\A[nN]\z/) ? raw.downcase : nil
+        end
+
         def parse_lower(row)
           Integer(row.lowerbound || 1)
         rescue StandardError
@@ -49,10 +58,11 @@ module Ea
         end
 
         def parse_upper(row)
-          return -1 if row.upperbound.to_s == "*"
+          raw = row.upperbound.to_s
+          return -1 if raw.match?(/\A[*nN]\z/)
 
           begin
-            Integer(row.upperbound || 1)
+            Integer(raw.empty? ? 1 : raw)
           rescue StandardError
             1
           end

data/lib/ea/svg/ea_emitter/compartment/attributes.rb

@@ -10,6 +10,7 @@ module Ea
 
           def render(context)
             return nil if context.attr_lines.empty?
+            return nil unless context.geometry.attr_first_y
 
             Element::AttributeRenderer.render(
               context.attr_lines,

data/lib/ea/svg/ea_emitter/compartment/constraints.rb

@@ -14,6 +14,7 @@ module Ea
 
           def render(context)
             return nil unless context.constraints&.any?
+            return nil unless context.geometry.tagged_value_first_y
 
             Element::ConstraintRenderer.render(
               context.constraints,

data/lib/ea/svg/ea_emitter/compartment/enum_literals.rb

@@ -10,45 +10,29 @@ module Ea
         module EnumLiterals
           module_function
 
+          # EA: literal rows sit directly under the header divider,
+          # 13px apart at 7pt (attr rows use 14), first row at
+          # divider + 14. No compartment divider, no header label.
+          LITERAL_LINE_OFFSET = 6
+
           def render(context)
             return nil unless context.enum_literals.any?
             return nil unless context.geometry.enum_literal_first_y
 
-            [
-              Element::DividerRenderer.render(
-                context.bounds,
-                y: context.geometry.enum_divider_y,
-                stroke: context.stroke,
-                stroke_width: context.stroke_width
-              ),
-              render_literals_block(context)
-            ].join("\n")
+            render_literals_block(context)
           end
 
           def render_literals_block(context)
-            line_h = context.size + (context.theme.compartments.attr_line_offset || 4)
-            text_blocks = [literal_header_text(context)]
+            line_h = context.size + LITERAL_LINE_OFFSET
+            text_blocks = []
             context.enum_literals.each_with_index do |literal, idx|
-              y = context.geometry.enum_literal_first_y + ((idx + 1) * line_h)
+              y = context.geometry.enum_literal_first_y + (idx * line_h)
               text_blocks << visibility_placeholder(context, y)
               text_blocks << literal_name_text(context, literal, y)
             end
             wrap_group(text_blocks, context.theme.text_color)
           end
 
-          def literal_header_text(context)
-            TextRenderer.new(
-              content: "literals",
-              x: context.bounds.x + (context.bounds.width / 2.0) -
-                (8 * context.size * context.theme.text_width_factor) / 2,
-              y: context.geometry.enum_literal_first_y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
-              style: "italic", fill: context.theme.text_color,
-              stroke_in_text: context.theme.stroke_in_text_color,
-              width_factor: context.theme.text_width_factor
-            ).to_svg
-          end
-
           def visibility_placeholder(context, y)
             TextRenderer.new(
               content: " ",

data/lib/ea/svg/ea_emitter/compartment/header.rb

@@ -11,6 +11,7 @@ module Ea
 
           def render(context)
             return nil if context.header_lines.empty?
+            return nil unless context.geometry.header_first_y
 
             Element::HeaderRenderer.render(
               context.header_lines,

data/lib/ea/svg/ea_emitter/element/attribute_line_builder.rb

@@ -103,6 +103,11 @@ module Ea
           end
 
           def bound_text(value)
+            # EA renders a stored literal bound ("n") verbatim, and a
+            # computed-unbounded upper as "*" (verified against
+            # EA-published reference SVGs).
+            return property.multiplicity_upper_raw if value == -1 && property.multiplicity_upper_raw
+
             value == -1 ? "*" : value.to_s
           end
         end

data/lib/ea/svg/ea_emitter/element/attribute_renderer.rb

@@ -9,15 +9,19 @@ module Ea
         # content) matching EA's encoding.
         class AttributeRenderer
           DEFAULT_VISIBILITY_X_OFFSET = 5
-          DEFAULT_CONTENT_X_OFFSET = 26
+          DEFAULT_CONTENT_X_OFFSET = 22
           DEFAULT_FONT_UNIT = "pt"
+          # EA seats compartment stereotype headers («Property») 12px
+          # from the box edge and spaces rows 13px at 7pt.
+          STEREOTYPE_HEADER_X_OFFSET = 12
+          ROW_LINE_OFFSET = 6
 
           def self.render(lines, bounds:, first_y:, family:,
                           size:, size_unit: DEFAULT_FONT_UNIT,
                           fill: "#000000",
                           visibility_x_offset: DEFAULT_VISIBILITY_X_OFFSET,
                           content_x_offset: DEFAULT_CONTENT_X_OFFSET)
-            line_h = size + 4
+            line_h = size + ROW_LINE_OFFSET
             text_blocks = []
             lines.each_with_index do |line, idx|
               y = first_y + (idx * line_h)
@@ -25,6 +29,8 @@ module Ea
               if visibility
                 text_blocks << build_text(bounds.x + visibility_x_offset, y, visibility, family, size, size_unit, fill)
                 text_blocks << build_text(bounds.x + content_x_offset, y, rest, family, size, size_unit, fill)
+              elsif line.strip.start_with?("«")
+                text_blocks << build_text(bounds.x + STEREOTYPE_HEADER_X_OFFSET, y, line.strip, family, size, size_unit, fill)
               else
                 text_blocks << build_text(bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill)
               end
@@ -44,19 +50,44 @@ module Ea
           #
           # Pass a `lookup` (any callable returning a Classifier for
           # an id) to enable inherited-property namespace prefixing.
-          def self.lines_for(classifier, lookup: nil)
-            props = displayable_properties(classifier)
+          def self.lines_for(classifier, lookup: nil,
+                            exclude_association_ids: nil)
+            props = displayable_properties(classifier, exclude_association_ids)
             return [] unless props
 
-            props.flat_map do |prop|
-              lines = []
-              stereotype = property_stereotype(prop)
-              lines << "«#{stereotype}»" if stereotype
-              lines << AttributeLineBuilder.new(prop, host: classifier,
+            stereotypes = props.map { |p| property_stereotype(p) }.compact.uniq
+            if stereotypes.size == 1 && props.all? { |p| property_stereotype(p) }
+              # EA renders ONE compartment stereotype header for a
+              # uniformly-stereotyped attribute set (e.g. «Property»
+              # above GML property rows) and lists rows
+              # alphabetically - verified against EA-published SVGs.
+              header = "«#{canonical_stereotype(stereotypes.first)}»"
+              [header] + props.sort_by { |p| p.name.to_s }.map do |prop|
+                AttributeLineBuilder.new(prop, host: classifier,
+                                         lookup: lookup).to_s
+              end
+            else
+              props.flat_map do |prop|
+                lines = []
+                stereotype = property_stereotype(prop)
+                lines << "«#{stereotype}»" if stereotype
+                lines << AttributeLineBuilder.new(prop, host: classifier,
                                                   lookup: lookup).to_s
+              end
             end
           end
 
+          STEREOTYPE_DISPLAY = {
+            "property" => "Property",
+            "featuretype" => "FeatureType",
+            "objecttype" => "ObjectType",
+            "codelist" => "CodeList"
+          }.freeze
+
+          def self.canonical_stereotype(ref)
+            STEREOTYPE_DISPLAY.fetch(ref.to_s.downcase, ref.to_s)
+          end
+
           # Internal helpers
 
           def self.split_visibility(line)
@@ -75,10 +106,19 @@ module Ea
           end
           private_class_method :build_text
 
-          def self.displayable_properties(classifier)
+          # Association-end properties render in the box only when
+          # their association is NOT drawn on the diagram (drawn ones
+          # render as connector role labels). exclude_association_ids
+          # carries the diagram's drawn association ids; nil preserves
+          # the legacy hide-all behavior.
+          def self.displayable_properties(classifier, exclude_association_ids)
             return nil unless classifier.properties
 
-            classifier.properties.reject(&:association_id)
+            classifier.properties.reject do |prop|
+              prop.association_id &&
+                (exclude_association_ids.nil? ||
+                 exclude_association_ids.include?(prop.association_id))
+            end
           end
           private_class_method :displayable_properties
 

data/lib/ea/svg/ea_emitter/element/compartment_geometry.rb

@@ -27,10 +27,10 @@ module Ea
           def initialize(bounds:, size:, header_lines_count:,
                           attr_lines_count:, op_lines_count:,
                           tagged_values_count:,
-                          header_top_padding: 9,
+                          header_top_padding: 12,
                           header_line_offset: 6,
                           divider_offset: 8,
-                          attr_line_offset: 4,
+                          attr_line_offset: 6,
                           attr_first_offset: 7)
             @bounds = bounds
             @size = size
@@ -46,7 +46,7 @@ module Ea
           end
 
           def header_first_y
-            bounds.y + size + (header_top_padding || 9)
+            bounds.y + size + (header_top_padding || 12)
           end
 
           # Y of the divider line between header and the rest.
@@ -61,7 +61,7 @@ module Ea
           end
 
           def attr_first_y
-            return bounds.y + size + (header_top_padding || 9) + 12 unless divider_y
+            return bounds.y + size + (header_top_padding || 12) + 12 unless divider_y
 
             divider_y + size + (attr_first_offset || 7)
           end
@@ -69,7 +69,7 @@ module Ea
           def attr_bottom_y
             return attr_first_y unless attr_lines_count&.positive?
 
-            attr_first_y + (attr_lines_count - 1) * (size + (attr_line_offset || 4))
+            attr_first_y + (attr_lines_count - 1) * (size + (attr_line_offset || 6))
           end
 
           def op_divider_y
@@ -88,12 +88,14 @@ module Ea
             op_first_y + (op_lines_count - 1) * (size + 4)
           end
 
-          def enum_divider_y
-            op_bottom_y + size + 5
-          end
-
+          # EA draws a single divider under the header and seats
+          # enumeration literals directly after it (+14 at 7pt),
+          # exactly like attribute rows - no second divider and no
+          # "literals" header. Verified against EA-published SVGs.
           def enum_literal_first_y
-            enum_divider_y + size + 5
+            return nil unless divider_y
+
+            divider_y + size + (attr_first_offset || 7)
           end
 
           # Tagged values appear after attributes (or after ops if

data/lib/ea/svg/ea_emitter/element/header_line_provider/name.rb

@@ -51,22 +51,13 @@ module Ea
                 (bounds_width - QUALIFIED_WRAP_PADDING)
             end
 
-            def self.display_name(classifier, diagram_package_id = nil,
+            # EA renders the plain classifier name in element headers
+            # (element ownership qualification is a display option the
+            # corpus diagrams leave off - verified against EA-published
+            # reference SVGs).
+            def self.display_name(classifier, _diagram_package_id = nil,
                                   _visually_nested = false)
-              name = if classifier.is_a?(Ea::Model::Classifier)
-                       (classifier.qualified_name || classifier.name).to_s
-                     else
-                       classifier.name.to_s
-                     end
-              return name if diagram_package_id.nil?
-              return name unless name.include?("::")
-
-              if classifier.is_a?(Ea::Model::Classifier) &&
-                 classifier.package_id == diagram_package_id
-                name.split("::").last
-              else
-                name
-              end
+              classifier.name.to_s
             end
           end
         end